@zudojs/cqrs 0.1.0 → 1.0.1

package/dist/cqrsMiddleware/cqrsMiddleware.core.js

@@ -1,27 +1,75 @@
-import { BaseError, ErrorCategory, ErrorCode, ErrorSeverity, } from "@zudojs/errors";
+import { BaseError } from "@zudojs/errors";
+import { CqrsError, CqrsValidationError, InvalidMiddlewareError, MiddlewareExecutionError, } from "../cqrsErrors/cqrsError.base.js";
 /**
  * Middleware that measures command or query execution time.
+ *
+ * Every measurement is reported through `options.onTiming` (when given)
+ * and stored on the returned middleware as `lastTiming`.
  */
 export function timingMiddleware(options = {}) {
+    if (options.onTiming !== undefined && typeof options.onTiming !== "function") {
+        throw new InvalidMiddlewareError("timingMiddleware onTiming must be a function.");
+    }
+    if (options.now !== undefined && typeof options.now !== "function") {
+        throw new InvalidMiddlewareError("timingMiddleware now must be a function.");
+    }
     const name = options.name ?? "timing";
-    return async (request, context, next) => {
+    const now = options.now ?? (() => performance.now());
+    const onTiming = options.onTiming;
+    let lastTiming;
+    let count = 0;
+    const record = async (timing) => {
+        lastTiming = timing;
+        count += 1;
+        if (onTiming) {
+            await onTiming(timing);
+        }
+    };
+    const middleware = async (request, context, next) => {
         if (options.enabled === false) {
             return next(request, context);
         }
-        const startedAt = Date.now();
+        const startedAt = now();
+        let result;
         try {
-            return await next(request, context);
+            result = await next(request, context);
         }
-        finally {
-            const duration = Date.now() - startedAt;
-            void name;
-            void duration;
+        catch (error) {
+            await record({
+                name,
+                request,
+                context,
+                durationMs: now() - startedAt,
+                succeeded: false,
+                error,
+            });
+            throw error;
         }
+        await record({
+            name,
+            request,
+            context,
+            durationMs: now() - startedAt,
+            succeeded: true,
+        });
+        return result;
     };
+    Object.defineProperty(middleware, "lastTiming", {
+        enumerable: true,
+        get: () => lastTiming,
+    });
+    Object.defineProperty(middleware, "count", {
+        enumerable: true,
+        get: () => count,
+    });
+    return middleware;
 }
 /**
  * Middleware that catches unknown exceptions and normalizes them
- * into BaseError instances.
+ * into `CqrsError` instances.
+ *
+ * `BaseError` instances (including every CQRS error) pass through
+ * unchanged.
  */
 export function errorMiddleware(options = {}) {
     return async (request, context, next) => {
@@ -35,23 +83,20 @@ export function errorMiddleware(options = {}) {
             if (error instanceof BaseError) {
                 throw error;
             }
-            throw new BaseError(error instanceof Error ? error.message : "CQRS execution failed.", {
-                code: ErrorCode.INTERNAL_ERROR,
-                category: ErrorCategory.SYSTEM,
-                severity: ErrorSeverity.ERROR,
-                statusCode: 500,
+            throw new CqrsError(error instanceof Error ? error.message : "CQRS execution failed.", {
                 expose: false,
                 isOperational: false,
                 cause: error,
                 metadata: {
-                    requestType: request.type,
+                    requestType: getRequestType(request),
                 },
             });
         }
     };
 }
 /**
- * Middleware that validates the basic CQRS request structure.
+ * Middleware that validates the basic CQRS request structure and throws
+ * `CqrsValidationError` when it is malformed.
  */
 export function validationMiddleware(options = {}) {
     return async (request, context, next) => {
@@ -62,14 +107,7 @@ export function validationMiddleware(options = {}) {
             typeof request !== "object" ||
             typeof request.type !== "string" ||
             request.type.trim().length === 0) {
-            throw new BaseError("A valid CQRS request with a type is required.", {
-                code: ErrorCode.INVALID_INPUT,
-                category: ErrorCategory.VALIDATION,
-                severity: ErrorSeverity.WARNING,
-                statusCode: 400,
-                expose: true,
-                isOperational: true,
-            });
+            throw new CqrsValidationError("A valid CQRS request with a type is required.");
         }
         return next(request, context);
     };
@@ -86,30 +124,65 @@ export function contextMiddleware(options = {}) {
             ...(context ?? {}),
             metadata: {
                 ...(context?.metadata ?? {}),
-                cqrsRequestType: request.type,
+                cqrsRequestType: getRequestType(request),
             },
         };
         return next(request, enrichedContext);
     };
 }
 /**
- * Creates locking middleware.
+ * Creates locking middleware that prevents concurrent execution of
+ * requests sharing the same lock key.
  */
 export function lockMiddleware(lock, options = {}) {
     if (!lock || typeof lock.acquire !== "function") {
-        throw new TypeError("A valid CQRS lock implementation is required.");
+        throw new InvalidMiddlewareError("A valid CQRS lock implementation with an acquire() method is required.");
+    }
+    if (options.key !== undefined && typeof options.key !== "function") {
+        throw new InvalidMiddlewareError("lockMiddleware key selector must be a function.");
     }
     return async (request, context, next) => {
         if (options.enabled === false) {
             return next(request, context);
         }
-        const release = await lock.acquire(request.type);
+        const key = options.key
+            ? options.key(request, context)
+            : (getRequestType(request) ?? "");
+        const release = await lock.acquire(key);
+        if (typeof release !== "function") {
+            throw new InvalidMiddlewareError(`CQRS lock acquire() must resolve to a release function (key "${key}").`, {
+                lockKey: key,
+            });
+        }
+        // `release()` may be asynchronous (a Redis DEL, say). It used to be
+        // called and dropped, so a rejected release was an unhandled promise
+        // rejection — which terminates the process under Node's defaults.
+        let result;
         try {
-            return await next(request, context);
+            result = await next(request, context);
+        }
+        catch (error) {
+            try {
+                await release();
+            }
+            catch {
+                // The handler's failure is the one the caller needs to see.
+            }
+            throw error;
         }
-        finally {
-            release();
+        try {
+            await release();
+        }
+        catch (error) {
+            throw new CqrsError(`CQRS lock release failed (key "${key}").`, {
+                cause: error,
+                metadata: {
+                    lockKey: key,
+                    requestType: getRequestType(request),
+                },
+            });
         }
+        return result;
     };
 }
 /**
@@ -130,6 +203,11 @@ export function queryMiddleware(middleware) {
 }
 /**
  * Combines multiple middleware functions into a single middleware.
+ *
+ * Each middleware may call `next()` at most once per execution; a second
+ * call throws `MiddlewareExecutionError`. The command and query buses
+ * build their pipelines with this function, so the same rule applies
+ * there.
  */
 export function composeMiddleware(middleware) {
     const stack = [...middleware];
@@ -137,7 +215,7 @@ export function composeMiddleware(middleware) {
         let index = -1;
         const dispatch = async (currentIndex, currentRequest, currentContext) => {
             if (currentIndex <= index) {
-                throw new Error("CQRS middleware called next() more than once.");
+                throw new MiddlewareExecutionError();
             }
             index = currentIndex;
             const current = stack[currentIndex];
@@ -182,4 +260,17 @@ export function onErrorMiddleware(callback) {
         }
     };
 }
+/**
+ * Reads the request discriminator defensively.
+ *
+ * Validation now runs inside the pipeline, so middleware may observe a
+ * malformed request before the bus rejects it.
+ */
+function getRequestType(request) {
+    if (typeof request !== "object" || request === null) {
+        return undefined;
+    }
+    const type = request.type;
+    return typeof type === "string" ? type : undefined;
+}
 //# sourceMappingURL=cqrsMiddleware.core.js.map

package/dist/cqrsMiddleware/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * @zudojs/cqrs/cqrsMiddleware
  *
- * Built-in CQRS middleware: timing, error handling, validation, and composition.
+ * Built-in CQRS middleware: timing, error handling, validation, locking,
+ * context enrichment, lifecycle callbacks, and composition.
  */
 export * from "./cqrsMiddleware.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/cqrsMiddleware/index.js

@@ -1,7 +1,8 @@
 /**
  * @zudojs/cqrs/cqrsMiddleware
  *
- * Built-in CQRS middleware: timing, error handling, validation, and composition.
+ * Built-in CQRS middleware: timing, error handling, validation, locking,
+ * context enrichment, lifecycle callbacks, and composition.
  */
 export * from "./cqrsMiddleware.core.js";
 //# sourceMappingURL=index.js.map

package/dist/cqrsTypes/cqrsTypes.type.d.ts

@@ -28,28 +28,20 @@ export interface CqrsContext {
     readonly tenantId?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
-/**
- * Result returned by a command handler.
- */
-export interface CommandResult<TResult = void> {
-    readonly result: TResult;
-    readonly commandType?: string;
-}
-/**
- * Result returned by a query handler.
- */
-export interface QueryResult<TResult> {
-    readonly result: TResult;
-    readonly queryType?: string;
-}
 /**
  * Generic command handler contract.
+ *
+ * Any object exposing an `execute` method satisfies this contract; the
+ * abstract `CommandHandler` class in `command/` is one implementation.
  */
 export interface CommandHandler<TCommand extends Command = Command, TResult = void> {
     execute(command: TCommand, context?: CqrsContext): Promise<TResult> | TResult;
 }
 /**
  * Generic query handler contract.
+ *
+ * Any object exposing an `execute` method satisfies this contract; the
+ * abstract `QueryHandler` class in `query/` is one implementation.
  */
 export interface QueryHandler<TQuery extends Query = Query, TResult = unknown> {
     execute(query: TQuery, context?: CqrsContext): Promise<TResult> | TResult;
@@ -121,16 +113,23 @@ export interface QueryBus {
 }
 /**
  * Converts a command type into a strongly typed command definition.
+ *
+ * The payload defaults to an empty object (`Record<never, never>`), so
+ * `CommandOf<"Ping">` is satisfied by `{ type: "Ping" }`. A `type` key in
+ * the payload is dropped: the discriminator always wins, mirroring
+ * `createCommand`.
  */
-export type CommandOf<TType extends string, TPayload extends Record<string, unknown> = Record<string, never>> = Readonly<{
+export type CommandOf<TType extends string, TPayload extends Record<string, unknown> = Record<never, never>> = Readonly<{
     readonly type: TType;
-} & TPayload>;
+} & Omit<TPayload, "type">>;
 /**
  * Converts a query type into a strongly typed query definition.
+ *
+ * See `CommandOf` for the payload defaulting and `type` precedence rules.
  */
-export type QueryOf<TType extends string, TPayload extends Record<string, unknown> = Record<string, never>> = Readonly<{
+export type QueryOf<TType extends string, TPayload extends Record<string, unknown> = Record<never, never>> = Readonly<{
     readonly type: TType;
-} & TPayload>;
+} & Omit<TPayload, "type">>;
 /**
  * Extracts the type discriminator from a CQRS request.
  */
@@ -139,18 +138,6 @@ export type CqrsRequestType<TRequest extends CqrsRequest> = TRequest["type"];
  * Extracts the payload of a command or query without its discriminator.
  */
 export type CqrsPayload<TRequest extends CqrsRequest> = Omit<TRequest, "type">;
-/**
- * Determines whether a value is a command.
- */
-export declare function isCommand(value: unknown): value is Command;
-/**
- * Determines whether a value is a query.
- *
- * Since commands and queries share the same runtime shape, this helper
- * should normally be used only when the surrounding code already knows
- * the request belongs to the query pipeline.
- */
-export declare function isQuery(value: unknown): value is Query;
 /**
  * Determines whether an unknown value satisfies the basic CQRS request shape.
  */

package/dist/cqrsTypes/cqrsTypes.type.js

@@ -5,22 +5,6 @@
  * Commands represent state-changing operations, while queries represent
  * read-only operations.
  */
-/**
- * Determines whether a value is a command.
- */
-export function isCommand(value) {
-    return isCqrsRequest(value) && "type" in value;
-}
-/**
- * Determines whether a value is a query.
- *
- * Since commands and queries share the same runtime shape, this helper
- * should normally be used only when the surrounding code already knows
- * the request belongs to the query pipeline.
- */
-export function isQuery(value) {
-    return isCqrsRequest(value);
-}
 /**
  * Determines whether an unknown value satisfies the basic CQRS request shape.
  */

package/dist/cqrsValidation/cqrsValidation.core.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Handler kinds accepted by the validation helpers.
+ */
+export type ValidatedHandlerKind = "command" | "query";
+/**
+ * Determines whether a value is a well-formed handler type discriminator:
+ * a non-empty string without leading or trailing whitespace.
+ */
+export declare function isValidHandlerType(type: unknown): type is string;
+/**
+ * Asserts that a handler type discriminator is well-formed.
+ *
+ * Registration keys are stored verbatim, so surrounding whitespace is
+ * rejected instead of silently creating an unreachable registration.
+ */
+export declare function assertHandlerType(kind: ValidatedHandlerKind, type: unknown): asserts type is string;
+/**
+ * Determines whether a value can be executed as a handler: either a
+ * function or an object exposing a callable `execute` method.
+ */
+export declare function isExecutableHandler(value: unknown): value is ((...args: unknown[]) => unknown) | {
+    execute: (...args: unknown[]) => unknown;
+};
+/**
+ * Asserts that a value can be executed as a handler.
+ */
+export declare function assertExecutableHandler(kind: ValidatedHandlerKind, type: string, handler: unknown): void;
+/**
+ * Asserts that a value is a middleware function.
+ */
+export declare function assertMiddleware(kind: ValidatedHandlerKind, middleware: unknown): asserts middleware is (...args: unknown[]) => unknown;
+//# sourceMappingURL=cqrsValidation.core.d.ts.map

package/dist/cqrsValidation/cqrsValidation.core.js

@@ -0,0 +1,53 @@
+import { HandlerConfigurationError, InvalidHandlerTypeError, InvalidMiddlewareError, } from "../cqrsErrors/cqrsError.base.js";
+/**
+ * Determines whether a value is a well-formed handler type discriminator:
+ * a non-empty string without leading or trailing whitespace.
+ */
+export function isValidHandlerType(type) {
+    return (typeof type === "string" && type.length > 0 && type.trim() === type);
+}
+/**
+ * Asserts that a handler type discriminator is well-formed.
+ *
+ * Registration keys are stored verbatim, so surrounding whitespace is
+ * rejected instead of silently creating an unreachable registration.
+ */
+export function assertHandlerType(kind, type) {
+    if (!isValidHandlerType(type)) {
+        throw new InvalidHandlerTypeError(kind, type);
+    }
+}
+/**
+ * Determines whether a value can be executed as a handler: either a
+ * function or an object exposing a callable `execute` method.
+ */
+export function isExecutableHandler(value) {
+    if (typeof value === "function") {
+        return true;
+    }
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.execute === "function");
+}
+/**
+ * Asserts that a value can be executed as a handler.
+ */
+export function assertExecutableHandler(kind, type, handler) {
+    if (!isExecutableHandler(handler)) {
+        throw new HandlerConfigurationError(`A valid ${kind} handler (a function or an object with an execute() method) is required for "${type}".`, {
+            handlerKind: kind,
+            handlerType: type,
+        });
+    }
+}
+/**
+ * Asserts that a value is a middleware function.
+ */
+export function assertMiddleware(kind, middleware) {
+    if (typeof middleware !== "function") {
+        throw new InvalidMiddlewareError(`${kind === "command" ? "Command" : "Query"} middleware must be a function.`, {
+            handlerKind: kind,
+        });
+    }
+}
+//# sourceMappingURL=cqrsValidation.core.js.map

package/dist/cqrsValidation/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/cqrs/cqrsValidation
+ *
+ * Shared argument validation used by the buses, registry and decorators.
+ */
+export * from "./cqrsValidation.core.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cqrsValidation/index.js

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/cqrs/cqrsValidation
+ *
+ * Shared argument validation used by the buses, registry and decorators.
+ */
+export * from "./cqrsValidation.core.js";
+//# sourceMappingURL=index.js.map

package/dist/handlerRegistry/handlerRegistry.core.d.ts

@@ -29,6 +29,11 @@ export type HandlerEntry = CommandHandlerEntry | QueryHandlerEntry;
  * The registry is intentionally independent from the buses so handlers
  * can be registered during application bootstrap and later consumed by
  * one or more buses.
+ *
+ * All failures are `CqrsError` instances: `InvalidHandlerTypeError` for
+ * malformed types, `HandlerConfigurationError` for non-callable handlers,
+ * `DuplicateHandlerError` for repeated registrations and
+ * `InvalidHandlerKindError` for kinds other than `"command"`/`"query"`.
  */
 export declare class HandlerRegistry {
     private readonly commandHandlers;

package/dist/handlerRegistry/handlerRegistry.core.js

@@ -1,9 +1,16 @@
+import { DuplicateHandlerError, InvalidHandlerKindError, } from "../cqrsErrors/cqrsError.base.js";
+import { assertExecutableHandler, assertHandlerType, } from "../cqrsValidation/cqrsValidation.core.js";
 /**
  * Central registry for CQRS command and query handlers.
  *
  * The registry is intentionally independent from the buses so handlers
  * can be registered during application bootstrap and later consumed by
  * one or more buses.
+ *
+ * All failures are `CqrsError` instances: `InvalidHandlerTypeError` for
+ * malformed types, `HandlerConfigurationError` for non-callable handlers,
+ * `DuplicateHandlerError` for repeated registrations and
+ * `InvalidHandlerKindError` for kinds other than `"command"`/`"query"`.
  */
 export class HandlerRegistry {
     commandHandlers = new Map();
@@ -15,7 +22,7 @@ export class HandlerRegistry {
         this.validateType(type, "command");
         this.validateHandler(handler, "command", type);
         if (this.commandHandlers.has(type)) {
-            throw new Error(`A command handler is already registered for "${type}".`);
+            throw new DuplicateHandlerError("command", type);
         }
         this.commandHandlers.set(type, handler);
         return this;
@@ -27,7 +34,7 @@ export class HandlerRegistry {
         this.validateType(type, "query");
         this.validateHandler(handler, "query", type);
         if (this.queryHandlers.has(type)) {
-            throw new Error(`A query handler is already registered for "${type}".`);
+            throw new DuplicateHandlerError("query", type);
         }
         this.queryHandlers.set(type, handler);
         return this;
@@ -36,10 +43,16 @@ export class HandlerRegistry {
      * Registers a generic handler entry.
      */
     register(entry) {
+        if (!entry || typeof entry !== "object") {
+            throw new InvalidHandlerKindError(entry);
+        }
         if (entry.kind === "command") {
             return this.registerCommand(entry.type, entry.handler);
         }
-        return this.registerQuery(entry.type, entry.handler);
+        if (entry.kind === "query") {
+            return this.registerQuery(entry.type, entry.handler);
+        }
+        throw new InvalidHandlerKindError(entry.kind);
     }
     /**
      * Registers multiple handlers.
@@ -84,6 +97,7 @@ export class HandlerRegistry {
      * Removes either a command or query handler.
      */
     unregister(kind, type) {
+        assertHandlerKind(kind);
         return kind === "command"
             ? this.unregisterCommand(type)
             : this.unregisterQuery(type);
@@ -116,6 +130,7 @@ export class HandlerRegistry {
      * Returns whether either kind of handler exists.
      */
     has(kind, type) {
+        assertHandlerKind(kind);
         return kind === "command" ? this.hasCommand(type) : this.hasQuery(type);
     }
     /**
@@ -189,15 +204,18 @@ export class HandlerRegistry {
         this.queryHandlers.clear();
     }
     validateType(type, kind) {
-        if (typeof type !== "string" || type.trim().length === 0) {
-            throw new TypeError(`${kind} type cannot be empty.`);
-        }
+        assertHandlerType(kind, type);
     }
     validateHandler(handler, kind, type) {
-        if (typeof handler !== "function" &&
-            (typeof handler !== "object" || handler === null)) {
-            throw new TypeError(`A valid ${kind} handler is required for "${type}".`);
-        }
+        assertExecutableHandler(kind, type, handler);
+    }
+}
+/**
+ * Asserts that a handler kind is one of the supported values.
+ */
+function assertHandlerKind(kind) {
+    if (kind !== "command" && kind !== "query") {
+        throw new InvalidHandlerKindError(kind);
     }
 }
 /**

package/dist/index.d.ts

@@ -4,14 +4,14 @@
  * Command Query Responsibility Segregation primitives for the Zudojs framework.
  * Provides buses, handlers, middleware, and execution infrastructure.
  */
-export { type CqrsContext, type CommandHandlerFunction, type QueryHandlerFunction, type CommandHandlerLike, type QueryHandlerLike, type CommandMiddleware, type QueryMiddleware, type CqrsMiddleware, type CqrsRequest, type CommandHandlerRegistration, type QueryHandlerRegistration, type CqrsBusOptions, type CommandOf, type QueryOf, type CqrsRequestType, type CqrsPayload, isCqrsRequest, } from "./cqrsTypes/index.js";
+export { type CqrsContext, type CommandHandler as CommandHandlerContract, type QueryHandler as QueryHandlerContract, type CommandHandlerFunction, type QueryHandlerFunction, type CommandHandlerLike, type QueryHandlerLike, type CommandMiddleware, type QueryMiddleware, type CqrsMiddleware, type CqrsRequest, type CommandHandlerRegistration, type QueryHandlerRegistration, type CqrsBusOptions, type CommandOf, type QueryOf, type CqrsRequestType, type CqrsPayload, isCqrsRequest, } from "./cqrsTypes/index.js";
 export { Command, type CommandOptions, MetadataCommand, createCommand, getCommandType, isCommand, commandType, CommandHandler, FunctionCommandHandler, createCommandHandler, isCommandHandler, isCommandHandlerLike, executeCommandHandler, CommandBus, type CommandBusOptions, type CommandRegistration, createCommandBus, type CommandResultStatus, type CommandResult, type CreateCommandResultOptions, createCommandResult, createFailedCommandResult, isSuccessfulCommandResult, isFailedCommandResult, unwrapCommandResult, withCommandResultMetadata, } from "./command/index.js";
 export { Query, type QueryOptions, MetadataQuery, createQuery, getQueryType, isQuery, queryType, QueryHandler, FunctionQueryHandler, createQueryHandler, isQueryHandler, isQueryHandlerLike, executeQueryHandler, QueryBus, type QueryBusOptions, type QueryRegistration, createQueryBus, type QueryResultStatus, type QueryResult, type CreateQueryResultOptions, createQueryResult, createFailedQueryResult, isSuccessfulQueryResult, isFailedQueryResult, unwrapQueryResult, withQueryResultMetadata, } from "./query/index.js";
 export { type Event, type EventInput, type EventDefinition, type EventType, type EventPayload, isEvent, createEvent as createBaseEvent, createEventId as createBaseEventId, } from "@zudojs/events";
 export * from "./cqrsEvents/index.js";
 export * from "./cqrsMiddleware/index.js";
 export * from "./handlerRegistry/index.js";
-export * from "./cqrsDecorators/index.js";
+export { type CqrsHandlerKind, type CqrsHandlerMetadata, type CommandHandlerMetadata, type QueryHandlerMetadata, type CqrsClass, type DecoratedCqrsClass, CqrsHandler, CommandHandlerFor, QueryHandlerFor, getCqrsHandlerMetadata, getCommandHandlerMetadata, getQueryHandlerMetadata, getCqrsType, isCqrsHandler, isDecoratedCommandHandler, isDecoratedQueryHandler, createCommandHandlerDecorator, createQueryHandlerDecorator, } from "./cqrsDecorators/index.js";
 export * from "./cqrsContext/index.js";
 export * from "./cqrsErrors/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -5,6 +5,10 @@
  * Provides buses, handlers, middleware, and execution infrastructure.
  */
 // Core types (interfaces, type aliases, type guards)
+//
+// The handler *interfaces* are exported as `CommandHandlerContract` /
+// `QueryHandlerContract` because the abstract classes below own the bare
+// `CommandHandler` / `QueryHandler` names.
 export { isCqrsRequest, } from "./cqrsTypes/index.js";
 // Command (classes, factories, type guards)
 export { Command, MetadataCommand, createCommand, getCommandType, isCommand, commandType, CommandHandler, FunctionCommandHandler, createCommandHandler, isCommandHandler, isCommandHandlerLike, executeCommandHandler, CommandBus, createCommandBus, createCommandResult, createFailedCommandResult, isSuccessfulCommandResult, isFailedCommandResult, unwrapCommandResult, withCommandResultMetadata, } from "./command/index.js";
@@ -17,8 +21,8 @@ export * from "./cqrsEvents/index.js";
 export * from "./cqrsMiddleware/index.js";
 // Handler Registry
 export * from "./handlerRegistry/index.js";
-// Decorators
-export * from "./cqrsDecorators/index.js";
+// Decorators (explicit list: nothing here may shadow the class exports above)
+export { CqrsHandler, CommandHandlerFor, QueryHandlerFor, getCqrsHandlerMetadata, getCommandHandlerMetadata, getQueryHandlerMetadata, getCqrsType, isCqrsHandler, isDecoratedCommandHandler, isDecoratedQueryHandler, createCommandHandlerDecorator, createQueryHandlerDecorator, } from "./cqrsDecorators/index.js";
 // Execution Context
 export * from "./cqrsContext/index.js";
 // Errors

package/dist/query/query.core.d.ts

@@ -24,10 +24,13 @@ export declare abstract class MetadataQuery<TType extends string = string> exten
 }
 /**
  * Creates a simple immutable query object.
+ *
+ * The `type` argument always wins over any `type` key present in the
+ * payload, so untrusted payloads cannot reroute the query.
  */
-export declare function createQuery<TType extends string, TPayload extends Record<string, unknown> = Record<string, never>>(type: TType, payload?: TPayload): Readonly<{
+export declare function createQuery<TType extends string, TPayload extends Record<string, unknown> = Record<never, never>>(type: TType, payload?: TPayload): Readonly<{
     readonly type: TType;
-} & TPayload>;
+} & Omit<TPayload, "type">>;
 /**
  * Returns the query type discriminator.
  */