@zudojs/messaging 0.1.0 → 1.0.1

package/dist/message/messageFactory.js

@@ -10,6 +10,39 @@
 export function createMessageId() {
     return `msg:${crypto.randomUUID()}`;
 }
+/**
+ * Rejects an empty or blank identifier.
+ */
+function assertNonEmptyId(value, kind) {
+    if (value.trim().length === 0) {
+        throw new TypeError(`A ${kind} must be a non-empty string.`);
+    }
+}
+/**
+ * Brands an existing string as a {@link MessageId}.
+ *
+ * Identifiers arriving from outside the process — a transport frame, a
+ * database row, a log record — are plain strings. This is the supported way
+ * to restore the branded type without an unchecked cast.
+ */
+export function toMessageId(value) {
+    assertNonEmptyId(value, "MessageId");
+    return value;
+}
+/**
+ * Brands an existing string as a {@link MessageCorrelationId}.
+ */
+export function toCorrelationId(value) {
+    assertNonEmptyId(value, "CorrelationId");
+    return value;
+}
+/**
+ * Brands an existing string as a {@link MessageCausationId}.
+ */
+export function toCausationId(value) {
+    assertNonEmptyId(value, "CausationId");
+    return value;
+}
 /**
  * Normalizes a message timestamp.
  */

package/dist/messageBus/messageBusCore.d.ts

@@ -5,7 +5,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 { MessageBus, MessageBusOptions } from "./messageBusType.type.js";
 import type { DispatchResult, DispatchOptions } from "../dispatcher/dispatcherType.type.js";
 /** Default in-memory message bus. */
@@ -13,12 +13,12 @@ export declare class InMemoryMessageBus implements MessageBus {
     private readonly dispatcher;
     private readonly registry;
     private readonly defaultTimeout;
+    private handlerSequence;
     private _disposed;
     constructor(options?: MessageBusOptions);
     private registerGlobalMiddleware;
     dispatch<TPayload, TResult>(message: Message<TPayload>, options?: DispatchOptions<TResult>): Promise<DispatchResult<TResult>>;
     private validateNotDisposed;
-    private dispatchWithTimeout;
     send<TPayload, TResult>(input: MessageInput<TPayload>, options?: DispatchOptions<TResult>): Promise<DispatchResult<TResult>>;
     on<TPayload, TResult>(messageType: string, handler: MessageHandler<Message<TPayload>, TResult>, options?: {
         id?: string;
@@ -26,7 +26,8 @@ export declare class InMemoryMessageBus implements MessageBus {
     }): void;
     addHandler<TMessage extends Message, TResult>(handler: NamedMessageHandler<TMessage, TResult>): void;
     off(handlerId: string): boolean;
-    use<TMessage extends Message = Message, TResult = unknown>(middleware: MessageMiddlewareLike<TMessage, TResult>): void;
+    use<TMessage extends Message = Message, TResult = unknown>(middleware: MessageMiddlewareLike<TMessage, TResult>, options?: MessageMiddlewareOptions): string;
+    removeMiddleware(middlewareId: string): boolean;
     hasHandlers(messageType: string): boolean;
     get handlerCount(): number;
     dispose(): void;

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;
             }
         };
     });
@@ -70,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

@@ -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,15 @@ 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[];
+    /**
+     * 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": "0.1.0",
+  "version": "1.0.1",
   "description": "In-process message bus infrastructure with handlers, middleware, and publish/subscribe patterns.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,26 +13,27 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clean": "rm -rf dist"
-  },
   "dependencies": {
-    "@zudojs/errors": "0.1.0",
-    "@zudojs/constants": "0.1.0"
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "devDependencies": {
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -43,8 +44,19 @@
     "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 && tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
   }
-}
+}