@saga-bus/middleware-validation 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dean Foran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,355 @@
+# @saga-bus/middleware-validation
+
+Validation middleware for saga-bus that validates message payloads before processing.
+
+## Installation
+
+```bash
+npm install @saga-bus/middleware-validation
+# or
+pnpm add @saga-bus/middleware-validation
+```
+
+For Zod support:
+
+```bash
+npm install zod
+```
+
+## Features
+
+- **Schema Validation**: Validate messages against Zod schemas or custom validators
+- **Multiple Actions**: Skip, log, throw, or DLQ invalid messages
+- **Strict Mode**: Optionally reject messages without registered validators
+- **Type Exclusions**: Skip validation for specific message types
+- **Custom Validators**: Use function-based validators for complex logic
+
+## Quick Start
+
+```typescript
+import { createBus } from "@saga-bus/core";
+import { z } from "zod";
+import {
+  createValidationMiddleware,
+  createZodValidator,
+} from "@saga-bus/middleware-validation";
+
+const OrderCreatedSchema = z.object({
+  type: z.literal("OrderCreated"),
+  orderId: z.string().uuid(),
+  customerId: z.string(),
+  items: z.array(z.object({
+    sku: z.string(),
+    quantity: z.number().positive(),
+  })).min(1),
+});
+
+const validationMiddleware = createValidationMiddleware({
+  validators: {
+    OrderCreated: createZodValidator(OrderCreatedSchema),
+  },
+  onInvalid: "throw",
+});
+
+const bus = createBus({
+  transport,
+  store,
+  sagas: [OrderSaga],
+  middleware: [validationMiddleware],
+});
+```
+
+## API Reference
+
+### createValidationMiddleware(options)
+
+Creates middleware that validates message payloads.
+
+```typescript
+interface ValidationMiddlewareOptions {
+  /** Map of message type to validator */
+  validators: Record<string, MessageValidator>;
+
+  /** Action on invalid: "skip" | "log" | "throw" | "dlq" (default: "throw") */
+  onInvalid?: "skip" | "log" | "throw" | "dlq";
+
+  /** Handler for DLQ (required if onInvalid is "dlq") */
+  deadLetterHandler?: (envelope: MessageEnvelope, errors: ValidationError[]) => Promise<void>;
+
+  /** Logger for validation errors */
+  logger?: { warn(...): void; error(...): void };
+
+  /** Reject messages without validators (default: false) */
+  strictMode?: boolean;
+
+  /** Message types to skip validation */
+  excludeTypes?: string[];
+}
+```
+
+### createZodValidator(schema)
+
+Creates a validator from a Zod schema.
+
+```typescript
+import { z } from "zod";
+import { createZodValidator } from "@saga-bus/middleware-validation";
+
+const validator = createZodValidator(z.object({
+  type: z.literal("OrderCreated"),
+  orderId: z.string(),
+}));
+```
+
+### createZodValidators(schemas)
+
+Creates multiple validators from a map of Zod schemas.
+
+```typescript
+import { createZodValidators } from "@saga-bus/middleware-validation";
+
+const validators = createZodValidators({
+  OrderCreated: OrderCreatedSchema,
+  OrderShipped: OrderShippedSchema,
+  PaymentReceived: PaymentReceivedSchema,
+});
+```
+
+### createFunctionValidator(fn)
+
+Creates a validator from a simple validation function.
+
+```typescript
+import { createFunctionValidator } from "@saga-bus/middleware-validation";
+
+const validator = createFunctionValidator((message) => {
+  if (!message.orderId) return "orderId is required";
+  if (message.items.length === 0) return "Order must have items";
+  return true;
+});
+```
+
+### combineValidators(validators)
+
+Combines multiple validators into one.
+
+```typescript
+import { combineValidators, createFunctionValidator } from "@saga-bus/middleware-validation";
+
+const validator = combineValidators([
+  createFunctionValidator((msg) => !!msg.orderId || "orderId required"),
+  createFunctionValidator((msg) => msg.items.length > 0 || "items required"),
+]);
+```
+
+### MessageValidationError
+
+Error thrown when validation fails and `onInvalid: "throw"`.
+
+```typescript
+import { MessageValidationError } from "@saga-bus/middleware-validation";
+
+try {
+  await bus.publish(message);
+} catch (error) {
+  if (error instanceof MessageValidationError) {
+    console.log(`Invalid message: ${error.messageId}`);
+    console.log(`Errors:`, error.validationErrors);
+  }
+}
+```
+
+## Examples
+
+### Basic Zod Validation
+
+```typescript
+import { z } from "zod";
+import { createValidationMiddleware, createZodValidator } from "@saga-bus/middleware-validation";
+
+const middleware = createValidationMiddleware({
+  validators: {
+    OrderCreated: createZodValidator(z.object({
+      type: z.literal("OrderCreated"),
+      orderId: z.string().uuid(),
+      customerId: z.string(),
+      items: z.array(z.object({
+        sku: z.string(),
+        quantity: z.number().int().positive(),
+        price: z.number().nonnegative(),
+      })).min(1),
+      total: z.number().nonnegative(),
+    })),
+  },
+});
+```
+
+### Custom Function Validator
+
+```typescript
+import { createValidationMiddleware, createFunctionValidator } from "@saga-bus/middleware-validation";
+
+const middleware = createValidationMiddleware({
+  validators: {
+    PaymentReceived: createFunctionValidator(async (message) => {
+      // Async validation - check against external service
+      const isValidPaymentId = await paymentService.verify(message.paymentId);
+      if (!isValidPaymentId) {
+        return "Invalid payment ID";
+      }
+      return true;
+    }),
+  },
+});
+```
+
+### Dead Letter Queue
+
+```typescript
+import { createValidationMiddleware } from "@saga-bus/middleware-validation";
+
+const middleware = createValidationMiddleware({
+  validators,
+  onInvalid: "dlq",
+  deadLetterHandler: async (envelope, errors) => {
+    await deadLetterQueue.send({
+      originalMessage: envelope,
+      validationErrors: errors,
+      timestamp: new Date(),
+    });
+  },
+  logger: console,
+});
+```
+
+### Strict Mode
+
+```typescript
+// Reject any message without a registered validator
+const middleware = createValidationMiddleware({
+  validators: {
+    OrderCreated: orderCreatedValidator,
+    OrderShipped: orderShippedValidator,
+  },
+  strictMode: true,
+  onInvalid: "throw",
+});
+```
+
+### Excluding Message Types
+
+```typescript
+// Don't validate system messages
+const middleware = createValidationMiddleware({
+  validators,
+  excludeTypes: ["Heartbeat", "HealthCheck", "SagaTimeoutExpired"],
+});
+```
+
+### Logging Invalid Messages
+
+```typescript
+import { logger } from "./logger";
+
+const middleware = createValidationMiddleware({
+  validators,
+  onInvalid: "log",
+  logger: {
+    warn: (msg, meta) => logger.warn(msg, meta),
+    error: (msg, meta) => logger.error(msg, meta),
+  },
+});
+```
+
+### Combining Multiple Validation Strategies
+
+```typescript
+import { combineValidators, createZodValidator, createFunctionValidator } from "@saga-bus/middleware-validation";
+import { z } from "zod";
+
+// Schema validation + business rule validation
+const orderValidator = combineValidators([
+  // Schema validation
+  createZodValidator(z.object({
+    type: z.literal("OrderCreated"),
+    orderId: z.string(),
+    customerId: z.string(),
+    items: z.array(z.object({
+      sku: z.string(),
+      quantity: z.number().positive(),
+    })),
+    total: z.number(),
+  })),
+
+  // Business rules
+  createFunctionValidator(async (msg) => {
+    const errors: string[] = [];
+
+    // Check customer exists
+    const customer = await customerService.get(msg.customerId);
+    if (!customer) {
+      errors.push(`Customer ${msg.customerId} not found`);
+    }
+
+    // Verify total matches items
+    const calculatedTotal = msg.items.reduce(
+      (sum, item) => sum + item.quantity * (item.price || 0),
+      0
+    );
+    if (Math.abs(calculatedTotal - msg.total) > 0.01) {
+      errors.push("Total doesn't match item prices");
+    }
+
+    return errors.length === 0 ? true : errors;
+  }),
+]);
+```
+
+## Custom Validator Implementation
+
+Create custom validators by implementing the `MessageValidator` interface:
+
+```typescript
+import type { MessageValidator, ValidationResult } from "@saga-bus/middleware-validation";
+
+const customValidator: MessageValidator = (message) => {
+  const errors = [];
+
+  if (!message.orderId) {
+    errors.push({ path: "orderId", message: "Required" });
+  }
+
+  if (message.items?.length === 0) {
+    errors.push({ path: "items", message: "Must have at least one item" });
+  }
+
+  return errors.length === 0
+    ? { valid: true }
+    : { valid: false, errors };
+};
+```
+
+## ValidationResult Interface
+
+```typescript
+interface ValidationResult {
+  valid: boolean;
+  errors?: Array<{
+    path: string;      // e.g., "items[0].quantity"
+    message: string;   // e.g., "Must be positive"
+    value?: unknown;   // The invalid value
+  }>;
+}
+```
+
+## Best Practices
+
+1. **Use Zod for complex schemas** - It provides excellent type inference and error messages
+2. **Use function validators for async/business logic** - External service calls, database lookups
+3. **Consider strict mode in production** - Catch unvalidated message types early
+4. **Use DLQ for debugging** - Store invalid messages for analysis
+5. **Exclude system messages** - Don't validate internal messages like timeouts
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MessageValidationError: () => MessageValidationError,
+  combineValidators: () => combineValidators,
+  createFunctionValidator: () => createFunctionValidator,
+  createValidationMiddleware: () => createValidationMiddleware,
+  createZodValidator: () => createZodValidator,
+  createZodValidators: () => createZodValidators
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var MessageValidationError = class extends Error {
+  messageId;
+  messageType;
+  validationErrors;
+  constructor(messageId, messageType, errors) {
+    const errorSummary = errors.map((e) => `${e.path}: ${e.message}`).join(", ");
+    super(`Validation failed for message ${messageId}: ${errorSummary}`);
+    this.name = "MessageValidationError";
+    this.messageId = messageId;
+    this.messageType = messageType;
+    this.validationErrors = errors;
+  }
+};
+
+// src/ValidationMiddleware.ts
+function createValidationMiddleware(options) {
+  const {
+    validators,
+    onInvalid = "throw",
+    deadLetterHandler,
+    logger,
+    strictMode = false,
+    excludeTypes = []
+  } = options;
+  if (onInvalid === "dlq" && !deadLetterHandler) {
+    throw new Error(
+      "deadLetterHandler is required when onInvalid is set to 'dlq'"
+    );
+  }
+  const excludeSet = new Set(excludeTypes);
+  return async (ctx, next) => {
+    const { envelope } = ctx;
+    const messageType = envelope.type;
+    if (excludeSet.has(messageType)) {
+      await next();
+      return;
+    }
+    const validator = validators[messageType];
+    if (!validator) {
+      if (strictMode) {
+        const errors = [
+          {
+            path: "type",
+            message: `No validator registered for message type: ${messageType}`
+          }
+        ];
+        await handleInvalidMessage(
+          ctx,
+          errors,
+          onInvalid,
+          deadLetterHandler,
+          logger
+        );
+        return;
+      }
+      await next();
+      return;
+    }
+    const result = await validator(envelope.payload);
+    if (result.valid) {
+      await next();
+      return;
+    }
+    await handleInvalidMessage(
+      ctx,
+      result.errors || [],
+      onInvalid,
+      deadLetterHandler,
+      logger
+    );
+  };
+}
+async function handleInvalidMessage(ctx, errors, onInvalid, deadLetterHandler, logger) {
+  const { envelope } = ctx;
+  switch (onInvalid) {
+    case "throw":
+      throw new MessageValidationError(envelope.id, envelope.type, errors);
+    case "dlq":
+      logger?.error("Invalid message, sending to DLQ", {
+        messageId: envelope.id,
+        messageType: envelope.type,
+        correlationId: ctx.correlationId,
+        sagaName: ctx.sagaName,
+        errors
+      });
+      await deadLetterHandler(envelope, errors);
+      break;
+    case "log":
+      logger?.warn("Invalid message detected, skipping", {
+        messageId: envelope.id,
+        messageType: envelope.type,
+        correlationId: ctx.correlationId,
+        sagaName: ctx.sagaName,
+        errors
+      });
+    // Fall through to skip
+    case "skip":
+    default:
+      break;
+  }
+}
+
+// src/validators/ZodValidator.ts
+function createZodValidator(schema) {
+  return (message) => {
+    const result = schema.safeParse(message);
+    if (result.success) {
+      return { valid: true };
+    }
+    const errors = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }));
+    return { valid: false, errors };
+  };
+}
+function createZodValidators(schemas) {
+  const validators = {};
+  for (const [type, schema] of Object.entries(schemas)) {
+    validators[type] = createZodValidator(schema);
+  }
+  return validators;
+}
+
+// src/validators/FunctionValidator.ts
+function createFunctionValidator(fn) {
+  return async (message) => {
+    const result = await fn(message);
+    if (result === true) {
+      return { valid: true };
+    }
+    const errors = [];
+    if (result === false) {
+      errors.push({ path: "", message: "Validation failed" });
+    } else if (typeof result === "string") {
+      errors.push({ path: "", message: result });
+    } else if (Array.isArray(result)) {
+      for (const msg of result) {
+        errors.push({ path: "", message: msg });
+      }
+    }
+    return { valid: false, errors };
+  };
+}
+function combineValidators(validators) {
+  return async (message) => {
+    const allErrors = [];
+    for (const validator of validators) {
+      const result = await validator(message);
+      if (!result.valid && result.errors) {
+        allErrors.push(...result.errors);
+      }
+    }
+    if (allErrors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors: allErrors };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MessageValidationError,
+  combineValidators,
+  createFunctionValidator,
+  createValidationMiddleware,
+  createZodValidator,
+  createZodValidators
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/types.ts","../src/ValidationMiddleware.ts","../src/validators/ZodValidator.ts","../src/validators/FunctionValidator.ts"],"sourcesContent":["export { createValidationMiddleware } from \"./ValidationMiddleware.js\";\nexport { createZodValidator, createZodValidators } from \"./validators/ZodValidator.js\";\nexport {\n  createFunctionValidator,\n  combineValidators,\n} from \"./validators/FunctionValidator.js\";\nexport {\n  MessageValidationError,\n  type ValidationMiddlewareOptions,\n  type ValidationResult,\n  type ValidationError,\n  type MessageValidator,\n  type SyncMessageValidator,\n  type AsyncMessageValidator,\n  type AnyMessageValidator,\n  type InvalidMessageAction,\n  type DeadLetterHandler,\n} from \"./types.js\";\n","import type { MessageEnvelope, BaseMessage } from \"@saga-bus/core\";\n\n/**\n * Result of a validation.\n */\nexport interface ValidationResult {\n  /** Whether the validation passed */\n  valid: boolean;\n  /** Validation errors if invalid */\n  errors?: ValidationError[];\n}\n\n/**\n * A single validation error.\n */\nexport interface ValidationError {\n  /** Path to the invalid field (e.g., \"payload.items[0].quantity\") */\n  path: string;\n  /** Error message */\n  message: string;\n  /** The invalid value */\n  value?: unknown;\n}\n\n/**\n * A synchronous validator function that validates a message.\n */\nexport type SyncMessageValidator<T extends BaseMessage = BaseMessage> = (\n  message: T\n) => ValidationResult;\n\n/**\n * An asynchronous validator function that validates a message.\n */\nexport type AsyncMessageValidator<T extends BaseMessage = BaseMessage> = (\n  message: T\n) => Promise<ValidationResult>;\n\n/**\n * A validator function that validates a message (sync or async).\n */\nexport type MessageValidator<T extends BaseMessage = BaseMessage> = (\n  message: T\n) => ValidationResult | Promise<ValidationResult>;\n\n/**\n * Action to take when validation fails.\n */\nexport type InvalidMessageAction = \"skip\" | \"log\" | \"throw\" | \"dlq\";\n\n/**\n * Dead-letter queue handler for invalid messages.\n */\nexport type DeadLetterHandler = (\n  envelope: MessageEnvelope,\n  errors: ValidationError[]\n) => Promise<void>;\n\n/**\n * A validator that can be used in the middleware (accepts any message type).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyMessageValidator = (message: any) => ValidationResult | Promise<ValidationResult>;\n\n/**\n * Options for the validation middleware.\n */\nexport interface ValidationMiddlewareOptions {\n  /**\n   * Map of message type to validator.\n   * Messages without a registered validator will pass through.\n   */\n  validators: Record<string, AnyMessageValidator>;\n\n  /**\n   * Action to take when validation fails.\n   * - \"skip\": Silently skip processing\n   * - \"log\": Log warning and skip\n   * - \"throw\": Throw a ValidationError\n   * - \"dlq\": Send to dead-letter queue handler\n   * @default \"throw\"\n   */\n  onInvalid?: InvalidMessageAction;\n\n  /**\n   * Handler for dead-letter queue (required if onInvalid is \"dlq\").\n   */\n  deadLetterHandler?: DeadLetterHandler;\n\n  /**\n   * Custom logger for validation errors.\n   */\n  logger?: {\n    warn(message: string, meta?: Record<string, unknown>): void;\n    error(message: string, meta?: Record<string, unknown>): void;\n  };\n\n  /**\n   * Whether to validate messages that don't have a registered validator.\n   * If true, messages without validators will be rejected.\n   * @default false\n   */\n  strictMode?: boolean;\n\n  /**\n   * Message types that should not be validated.\n   */\n  excludeTypes?: string[];\n}\n\n/**\n * Error thrown when validation fails and onInvalid is \"throw\".\n */\nexport class MessageValidationError extends Error {\n  public readonly messageId: string;\n  public readonly messageType: string;\n  public readonly validationErrors: ValidationError[];\n\n  constructor(\n    messageId: string,\n    messageType: string,\n    errors: ValidationError[]\n  ) {\n    const errorSummary = errors\n      .map((e) => `${e.path}: ${e.message}`)\n      .join(\", \");\n    super(`Validation failed for message ${messageId}: ${errorSummary}`);\n    this.name = \"MessageValidationError\";\n    this.messageId = messageId;\n    this.messageType = messageType;\n    this.validationErrors = errors;\n  }\n}\n","import type { SagaMiddleware, SagaPipelineContext } from \"@saga-bus/core\";\nimport type { ValidationMiddlewareOptions, ValidationError } from \"./types.js\";\nimport { MessageValidationError } from \"./types.js\";\n\n/**\n * Creates validation middleware that validates message payloads before processing.\n *\n * @example\n * ```typescript\n * import { createValidationMiddleware, createZodValidator } from \"@saga-bus/middleware-validation\";\n * import { z } from \"zod\";\n *\n * const validationMiddleware = createValidationMiddleware({\n *   validators: {\n *     OrderCreated: createZodValidator(z.object({\n *       type: z.literal(\"OrderCreated\"),\n *       orderId: z.string(),\n *       customerId: z.string(),\n *     })),\n *   },\n *   onInvalid: \"throw\",\n * });\n *\n * const bus = createBus({\n *   transport,\n *   store,\n *   sagas: [MySaga],\n *   middleware: [validationMiddleware],\n * });\n * ```\n */\nexport function createValidationMiddleware(\n  options: ValidationMiddlewareOptions\n): SagaMiddleware {\n  const {\n    validators,\n    onInvalid = \"throw\",\n    deadLetterHandler,\n    logger,\n    strictMode = false,\n    excludeTypes = [],\n  } = options;\n\n  // Validate options\n  if (onInvalid === \"dlq\" && !deadLetterHandler) {\n    throw new Error(\n      \"deadLetterHandler is required when onInvalid is set to 'dlq'\"\n    );\n  }\n\n  const excludeSet = new Set(excludeTypes);\n\n  return async (ctx: SagaPipelineContext, next: () => Promise<void>) => {\n    const { envelope } = ctx;\n    const messageType = envelope.type;\n\n    // Skip excluded types\n    if (excludeSet.has(messageType)) {\n      await next();\n      return;\n    }\n\n    // Get validator for this message type\n    const validator = validators[messageType];\n\n    // Handle missing validator\n    if (!validator) {\n      if (strictMode) {\n        const errors: ValidationError[] = [\n          {\n            path: \"type\",\n            message: `No validator registered for message type: ${messageType}`,\n          },\n        ];\n        await handleInvalidMessage(\n          ctx,\n          errors,\n          onInvalid,\n          deadLetterHandler,\n          logger\n        );\n        return;\n      }\n      // Not strict mode - pass through\n      await next();\n      return;\n    }\n\n    // Validate the message payload\n    const result = await validator(envelope.payload);\n\n    if (result.valid) {\n      await next();\n      return;\n    }\n\n    // Handle invalid message\n    await handleInvalidMessage(\n      ctx,\n      result.errors || [],\n      onInvalid,\n      deadLetterHandler,\n      logger\n    );\n  };\n}\n\nasync function handleInvalidMessage(\n  ctx: SagaPipelineContext,\n  errors: ValidationError[],\n  onInvalid: string,\n  deadLetterHandler: ((envelope: typeof ctx.envelope, errors: ValidationError[]) => Promise<void>) | undefined,\n  logger: { warn(message: string, meta?: Record<string, unknown>): void; error(message: string, meta?: Record<string, unknown>): void } | undefined\n): Promise<void> {\n  const { envelope } = ctx;\n\n  switch (onInvalid) {\n    case \"throw\":\n      throw new MessageValidationError(envelope.id, envelope.type, errors);\n\n    case \"dlq\":\n      logger?.error(\"Invalid message, sending to DLQ\", {\n        messageId: envelope.id,\n        messageType: envelope.type,\n        correlationId: ctx.correlationId,\n        sagaName: ctx.sagaName,\n        errors,\n      });\n      await deadLetterHandler!(envelope, errors);\n      break;\n\n    case \"log\":\n      logger?.warn(\"Invalid message detected, skipping\", {\n        messageId: envelope.id,\n        messageType: envelope.type,\n        correlationId: ctx.correlationId,\n        sagaName: ctx.sagaName,\n        errors,\n      });\n      // Fall through to skip\n\n    case \"skip\":\n    default:\n      // Don't call next() - silently skip processing\n      break;\n  }\n}\n","import type { BaseMessage } from \"@saga-bus/core\";\nimport type { SyncMessageValidator, ValidationResult, ValidationError, AnyMessageValidator } from \"../types.js\";\n\n// Type for Zod schema - we don't import zod directly to keep it optional\ninterface ZodSchema {\n  safeParse(data: unknown): {\n    success: boolean;\n    data?: unknown;\n    error?: {\n      issues: Array<{\n        path: (string | number)[];\n        message: string;\n      }>;\n    };\n  };\n}\n\n/**\n * Creates a validator from a Zod schema.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { createZodValidator } from \"@saga-bus/middleware-validation\";\n *\n * const OrderCreatedSchema = z.object({\n *   type: z.literal(\"OrderCreated\"),\n *   orderId: z.string().uuid(),\n *   customerId: z.string(),\n *   items: z.array(z.object({\n *     sku: z.string(),\n *     quantity: z.number().positive(),\n *   })),\n *   total: z.number().nonnegative(),\n * });\n *\n * const validator = createZodValidator(OrderCreatedSchema);\n * ```\n */\nexport function createZodValidator<T extends BaseMessage = BaseMessage>(schema: ZodSchema): SyncMessageValidator<T> {\n  return (message: T): ValidationResult => {\n    const result = schema.safeParse(message);\n\n    if (result.success) {\n      return { valid: true };\n    }\n\n    const errors: ValidationError[] = result.error!.issues.map((issue) => ({\n      path: issue.path.join(\".\"),\n      message: issue.message,\n    }));\n\n    return { valid: false, errors };\n  };\n}\n\n/**\n * Creates multiple validators from a map of Zod schemas.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { createZodValidators } from \"@saga-bus/middleware-validation\";\n *\n * const validators = createZodValidators({\n *   OrderCreated: z.object({\n *     type: z.literal(\"OrderCreated\"),\n *     orderId: z.string(),\n *   }),\n *   OrderShipped: z.object({\n *     type: z.literal(\"OrderShipped\"),\n *     orderId: z.string(),\n *     trackingNumber: z.string(),\n *   }),\n * });\n * ```\n */\nexport function createZodValidators(\n  schemas: Record<string, ZodSchema>\n): Record<string, AnyMessageValidator> {\n  const validators: Record<string, AnyMessageValidator> = {};\n\n  for (const [type, schema] of Object.entries(schemas)) {\n    validators[type] = createZodValidator(schema);\n  }\n\n  return validators;\n}\n","import type { BaseMessage } from \"@saga-bus/core\";\nimport type {\n  MessageValidator,\n  ValidationResult,\n  ValidationError,\n} from \"../types.js\";\n\n/**\n * A simple validation function that returns true/false or an error message.\n */\nexport type SimpleValidationFn<T> = (\n  message: T\n) => boolean | string | string[] | Promise<boolean | string | string[]>;\n\n/**\n * Creates a validator from a simple validation function.\n *\n * @example\n * ```typescript\n * import { createFunctionValidator } from \"@saga-bus/middleware-validation\";\n *\n * const validator = createFunctionValidator((message: OrderCreated) => {\n *   if (!message.orderId) {\n *     return \"orderId is required\";\n *   }\n *   if (message.items.length === 0) {\n *     return \"Order must have at least one item\";\n *   }\n *   return true;\n * });\n * ```\n */\nexport function createFunctionValidator<T extends BaseMessage = BaseMessage>(\n  fn: SimpleValidationFn<T>\n): MessageValidator<T> {\n  return async (message: T): Promise<ValidationResult> => {\n    const result = await fn(message);\n\n    if (result === true) {\n      return { valid: true };\n    }\n\n    const errors: ValidationError[] = [];\n\n    if (result === false) {\n      errors.push({ path: \"\", message: \"Validation failed\" });\n    } else if (typeof result === \"string\") {\n      errors.push({ path: \"\", message: result });\n    } else if (Array.isArray(result)) {\n      for (const msg of result) {\n        errors.push({ path: \"\", message: msg });\n      }\n    }\n\n    return { valid: false, errors };\n  };\n}\n\n/**\n * Combines multiple validators into one.\n * All validators must pass for the message to be valid.\n *\n * @example\n * ```typescript\n * import { combineValidators, createFunctionValidator } from \"@saga-bus/middleware-validation\";\n *\n * const validator = combineValidators([\n *   createFunctionValidator((msg) => !!msg.orderId || \"orderId required\"),\n *   createFunctionValidator((msg) => msg.items.length > 0 || \"items required\"),\n * ]);\n * ```\n */\nexport function combineValidators<T extends BaseMessage = BaseMessage>(\n  validators: MessageValidator<T>[]\n): MessageValidator<T> {\n  return async (message: T): Promise<ValidationResult> => {\n    const allErrors: ValidationError[] = [];\n\n    for (const validator of validators) {\n      const result = await validator(message);\n      if (!result.valid && result.errors) {\n        allErrors.push(...result.errors);\n      }\n    }\n\n    if (allErrors.length === 0) {\n      return { valid: true };\n    }\n\n    return { valid: false, errors: allErrors };\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,223 @@
+import { MessageEnvelope, BaseMessage, SagaMiddleware } from '@saga-bus/core';
+
+/**
+ * Result of a validation.
+ */
+interface ValidationResult {
+    /** Whether the validation passed */
+    valid: boolean;
+    /** Validation errors if invalid */
+    errors?: ValidationError[];
+}
+/**
+ * A single validation error.
+ */
+interface ValidationError {
+    /** Path to the invalid field (e.g., "payload.items[0].quantity") */
+    path: string;
+    /** Error message */
+    message: string;
+    /** The invalid value */
+    value?: unknown;
+}
+/**
+ * A synchronous validator function that validates a message.
+ */
+type SyncMessageValidator<T extends BaseMessage = BaseMessage> = (message: T) => ValidationResult;
+/**
+ * An asynchronous validator function that validates a message.
+ */
+type AsyncMessageValidator<T extends BaseMessage = BaseMessage> = (message: T) => Promise<ValidationResult>;
+/**
+ * A validator function that validates a message (sync or async).
+ */
+type MessageValidator<T extends BaseMessage = BaseMessage> = (message: T) => ValidationResult | Promise<ValidationResult>;
+/**
+ * Action to take when validation fails.
+ */
+type InvalidMessageAction = "skip" | "log" | "throw" | "dlq";
+/**
+ * Dead-letter queue handler for invalid messages.
+ */
+type DeadLetterHandler = (envelope: MessageEnvelope, errors: ValidationError[]) => Promise<void>;
+/**
+ * A validator that can be used in the middleware (accepts any message type).
+ */
+type AnyMessageValidator = (message: any) => ValidationResult | Promise<ValidationResult>;
+/**
+ * Options for the validation middleware.
+ */
+interface ValidationMiddlewareOptions {
+    /**
+     * Map of message type to validator.
+     * Messages without a registered validator will pass through.
+     */
+    validators: Record<string, AnyMessageValidator>;
+    /**
+     * Action to take when validation fails.
+     * - "skip": Silently skip processing
+     * - "log": Log warning and skip
+     * - "throw": Throw a ValidationError
+     * - "dlq": Send to dead-letter queue handler
+     * @default "throw"
+     */
+    onInvalid?: InvalidMessageAction;
+    /**
+     * Handler for dead-letter queue (required if onInvalid is "dlq").
+     */
+    deadLetterHandler?: DeadLetterHandler;
+    /**
+     * Custom logger for validation errors.
+     */
+    logger?: {
+        warn(message: string, meta?: Record<string, unknown>): void;
+        error(message: string, meta?: Record<string, unknown>): void;
+    };
+    /**
+     * Whether to validate messages that don't have a registered validator.
+     * If true, messages without validators will be rejected.
+     * @default false
+     */
+    strictMode?: boolean;
+    /**
+     * Message types that should not be validated.
+     */
+    excludeTypes?: string[];
+}
+/**
+ * Error thrown when validation fails and onInvalid is "throw".
+ */
+declare class MessageValidationError extends Error {
+    readonly messageId: string;
+    readonly messageType: string;
+    readonly validationErrors: ValidationError[];
+    constructor(messageId: string, messageType: string, errors: ValidationError[]);
+}
+
+/**
+ * Creates validation middleware that validates message payloads before processing.
+ *
+ * @example
+ * ```typescript
+ * import { createValidationMiddleware, createZodValidator } from "@saga-bus/middleware-validation";
+ * import { z } from "zod";
+ *
+ * const validationMiddleware = createValidationMiddleware({
+ *   validators: {
+ *     OrderCreated: createZodValidator(z.object({
+ *       type: z.literal("OrderCreated"),
+ *       orderId: z.string(),
+ *       customerId: z.string(),
+ *     })),
+ *   },
+ *   onInvalid: "throw",
+ * });
+ *
+ * const bus = createBus({
+ *   transport,
+ *   store,
+ *   sagas: [MySaga],
+ *   middleware: [validationMiddleware],
+ * });
+ * ```
+ */
+declare function createValidationMiddleware(options: ValidationMiddlewareOptions): SagaMiddleware;
+
+interface ZodSchema {
+    safeParse(data: unknown): {
+        success: boolean;
+        data?: unknown;
+        error?: {
+            issues: Array<{
+                path: (string | number)[];
+                message: string;
+            }>;
+        };
+    };
+}
+/**
+ * Creates a validator from a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createZodValidator } from "@saga-bus/middleware-validation";
+ *
+ * const OrderCreatedSchema = z.object({
+ *   type: z.literal("OrderCreated"),
+ *   orderId: z.string().uuid(),
+ *   customerId: z.string(),
+ *   items: z.array(z.object({
+ *     sku: z.string(),
+ *     quantity: z.number().positive(),
+ *   })),
+ *   total: z.number().nonnegative(),
+ * });
+ *
+ * const validator = createZodValidator(OrderCreatedSchema);
+ * ```
+ */
+declare function createZodValidator<T extends BaseMessage = BaseMessage>(schema: ZodSchema): SyncMessageValidator<T>;
+/**
+ * Creates multiple validators from a map of Zod schemas.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createZodValidators } from "@saga-bus/middleware-validation";
+ *
+ * const validators = createZodValidators({
+ *   OrderCreated: z.object({
+ *     type: z.literal("OrderCreated"),
+ *     orderId: z.string(),
+ *   }),
+ *   OrderShipped: z.object({
+ *     type: z.literal("OrderShipped"),
+ *     orderId: z.string(),
+ *     trackingNumber: z.string(),
+ *   }),
+ * });
+ * ```
+ */
+declare function createZodValidators(schemas: Record<string, ZodSchema>): Record<string, AnyMessageValidator>;
+
+/**
+ * A simple validation function that returns true/false or an error message.
+ */
+type SimpleValidationFn<T> = (message: T) => boolean | string | string[] | Promise<boolean | string | string[]>;
+/**
+ * Creates a validator from a simple validation function.
+ *
+ * @example
+ * ```typescript
+ * import { createFunctionValidator } from "@saga-bus/middleware-validation";
+ *
+ * const validator = createFunctionValidator((message: OrderCreated) => {
+ *   if (!message.orderId) {
+ *     return "orderId is required";
+ *   }
+ *   if (message.items.length === 0) {
+ *     return "Order must have at least one item";
+ *   }
+ *   return true;
+ * });
+ * ```
+ */
+declare function createFunctionValidator<T extends BaseMessage = BaseMessage>(fn: SimpleValidationFn<T>): MessageValidator<T>;
+/**
+ * Combines multiple validators into one.
+ * All validators must pass for the message to be valid.
+ *
+ * @example
+ * ```typescript
+ * import { combineValidators, createFunctionValidator } from "@saga-bus/middleware-validation";
+ *
+ * const validator = combineValidators([
+ *   createFunctionValidator((msg) => !!msg.orderId || "orderId required"),
+ *   createFunctionValidator((msg) => msg.items.length > 0 || "items required"),
+ * ]);
+ * ```
+ */
+declare function combineValidators<T extends BaseMessage = BaseMessage>(validators: MessageValidator<T>[]): MessageValidator<T>;
+
+export { type AnyMessageValidator, type AsyncMessageValidator, type DeadLetterHandler, type InvalidMessageAction, MessageValidationError, type MessageValidator, type SyncMessageValidator, type ValidationError, type ValidationMiddlewareOptions, type ValidationResult, combineValidators, createFunctionValidator, createValidationMiddleware, createZodValidator, createZodValidators };

package/dist/index.d.ts

@@ -0,0 +1,223 @@
+import { MessageEnvelope, BaseMessage, SagaMiddleware } from '@saga-bus/core';
+
+/**
+ * Result of a validation.
+ */
+interface ValidationResult {
+    /** Whether the validation passed */
+    valid: boolean;
+    /** Validation errors if invalid */
+    errors?: ValidationError[];
+}
+/**
+ * A single validation error.
+ */
+interface ValidationError {
+    /** Path to the invalid field (e.g., "payload.items[0].quantity") */
+    path: string;
+    /** Error message */
+    message: string;
+    /** The invalid value */
+    value?: unknown;
+}
+/**
+ * A synchronous validator function that validates a message.
+ */
+type SyncMessageValidator<T extends BaseMessage = BaseMessage> = (message: T) => ValidationResult;
+/**
+ * An asynchronous validator function that validates a message.
+ */
+type AsyncMessageValidator<T extends BaseMessage = BaseMessage> = (message: T) => Promise<ValidationResult>;
+/**
+ * A validator function that validates a message (sync or async).
+ */
+type MessageValidator<T extends BaseMessage = BaseMessage> = (message: T) => ValidationResult | Promise<ValidationResult>;
+/**
+ * Action to take when validation fails.
+ */
+type InvalidMessageAction = "skip" | "log" | "throw" | "dlq";
+/**
+ * Dead-letter queue handler for invalid messages.
+ */
+type DeadLetterHandler = (envelope: MessageEnvelope, errors: ValidationError[]) => Promise<void>;
+/**
+ * A validator that can be used in the middleware (accepts any message type).
+ */
+type AnyMessageValidator = (message: any) => ValidationResult | Promise<ValidationResult>;
+/**
+ * Options for the validation middleware.
+ */
+interface ValidationMiddlewareOptions {
+    /**
+     * Map of message type to validator.
+     * Messages without a registered validator will pass through.
+     */
+    validators: Record<string, AnyMessageValidator>;
+    /**
+     * Action to take when validation fails.
+     * - "skip": Silently skip processing
+     * - "log": Log warning and skip
+     * - "throw": Throw a ValidationError
+     * - "dlq": Send to dead-letter queue handler
+     * @default "throw"
+     */
+    onInvalid?: InvalidMessageAction;
+    /**
+     * Handler for dead-letter queue (required if onInvalid is "dlq").
+     */
+    deadLetterHandler?: DeadLetterHandler;
+    /**
+     * Custom logger for validation errors.
+     */
+    logger?: {
+        warn(message: string, meta?: Record<string, unknown>): void;
+        error(message: string, meta?: Record<string, unknown>): void;
+    };
+    /**
+     * Whether to validate messages that don't have a registered validator.
+     * If true, messages without validators will be rejected.
+     * @default false
+     */
+    strictMode?: boolean;
+    /**
+     * Message types that should not be validated.
+     */
+    excludeTypes?: string[];
+}
+/**
+ * Error thrown when validation fails and onInvalid is "throw".
+ */
+declare class MessageValidationError extends Error {
+    readonly messageId: string;
+    readonly messageType: string;
+    readonly validationErrors: ValidationError[];
+    constructor(messageId: string, messageType: string, errors: ValidationError[]);
+}
+
+/**
+ * Creates validation middleware that validates message payloads before processing.
+ *
+ * @example
+ * ```typescript
+ * import { createValidationMiddleware, createZodValidator } from "@saga-bus/middleware-validation";
+ * import { z } from "zod";
+ *
+ * const validationMiddleware = createValidationMiddleware({
+ *   validators: {
+ *     OrderCreated: createZodValidator(z.object({
+ *       type: z.literal("OrderCreated"),
+ *       orderId: z.string(),
+ *       customerId: z.string(),
+ *     })),
+ *   },
+ *   onInvalid: "throw",
+ * });
+ *
+ * const bus = createBus({
+ *   transport,
+ *   store,
+ *   sagas: [MySaga],
+ *   middleware: [validationMiddleware],
+ * });
+ * ```
+ */
+declare function createValidationMiddleware(options: ValidationMiddlewareOptions): SagaMiddleware;
+
+interface ZodSchema {
+    safeParse(data: unknown): {
+        success: boolean;
+        data?: unknown;
+        error?: {
+            issues: Array<{
+                path: (string | number)[];
+                message: string;
+            }>;
+        };
+    };
+}
+/**
+ * Creates a validator from a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createZodValidator } from "@saga-bus/middleware-validation";
+ *
+ * const OrderCreatedSchema = z.object({
+ *   type: z.literal("OrderCreated"),
+ *   orderId: z.string().uuid(),
+ *   customerId: z.string(),
+ *   items: z.array(z.object({
+ *     sku: z.string(),
+ *     quantity: z.number().positive(),
+ *   })),
+ *   total: z.number().nonnegative(),
+ * });
+ *
+ * const validator = createZodValidator(OrderCreatedSchema);
+ * ```
+ */
+declare function createZodValidator<T extends BaseMessage = BaseMessage>(schema: ZodSchema): SyncMessageValidator<T>;
+/**
+ * Creates multiple validators from a map of Zod schemas.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createZodValidators } from "@saga-bus/middleware-validation";
+ *
+ * const validators = createZodValidators({
+ *   OrderCreated: z.object({
+ *     type: z.literal("OrderCreated"),
+ *     orderId: z.string(),
+ *   }),
+ *   OrderShipped: z.object({
+ *     type: z.literal("OrderShipped"),
+ *     orderId: z.string(),
+ *     trackingNumber: z.string(),
+ *   }),
+ * });
+ * ```
+ */
+declare function createZodValidators(schemas: Record<string, ZodSchema>): Record<string, AnyMessageValidator>;
+
+/**
+ * A simple validation function that returns true/false or an error message.
+ */
+type SimpleValidationFn<T> = (message: T) => boolean | string | string[] | Promise<boolean | string | string[]>;
+/**
+ * Creates a validator from a simple validation function.
+ *
+ * @example
+ * ```typescript
+ * import { createFunctionValidator } from "@saga-bus/middleware-validation";
+ *
+ * const validator = createFunctionValidator((message: OrderCreated) => {
+ *   if (!message.orderId) {
+ *     return "orderId is required";
+ *   }
+ *   if (message.items.length === 0) {
+ *     return "Order must have at least one item";
+ *   }
+ *   return true;
+ * });
+ * ```
+ */
+declare function createFunctionValidator<T extends BaseMessage = BaseMessage>(fn: SimpleValidationFn<T>): MessageValidator<T>;
+/**
+ * Combines multiple validators into one.
+ * All validators must pass for the message to be valid.
+ *
+ * @example
+ * ```typescript
+ * import { combineValidators, createFunctionValidator } from "@saga-bus/middleware-validation";
+ *
+ * const validator = combineValidators([
+ *   createFunctionValidator((msg) => !!msg.orderId || "orderId required"),
+ *   createFunctionValidator((msg) => msg.items.length > 0 || "items required"),
+ * ]);
+ * ```
+ */
+declare function combineValidators<T extends BaseMessage = BaseMessage>(validators: MessageValidator<T>[]): MessageValidator<T>;
+
+export { type AnyMessageValidator, type AsyncMessageValidator, type DeadLetterHandler, type InvalidMessageAction, MessageValidationError, type MessageValidator, type SyncMessageValidator, type ValidationError, type ValidationMiddlewareOptions, type ValidationResult, combineValidators, createFunctionValidator, createValidationMiddleware, createZodValidator, createZodValidators };

package/dist/index.js

@@ -0,0 +1,169 @@
+// src/types.ts
+var MessageValidationError = class extends Error {
+  messageId;
+  messageType;
+  validationErrors;
+  constructor(messageId, messageType, errors) {
+    const errorSummary = errors.map((e) => `${e.path}: ${e.message}`).join(", ");
+    super(`Validation failed for message ${messageId}: ${errorSummary}`);
+    this.name = "MessageValidationError";
+    this.messageId = messageId;
+    this.messageType = messageType;
+    this.validationErrors = errors;
+  }
+};
+
+// src/ValidationMiddleware.ts
+function createValidationMiddleware(options) {
+  const {
+    validators,
+    onInvalid = "throw",
+    deadLetterHandler,
+    logger,
+    strictMode = false,
+    excludeTypes = []
+  } = options;
+  if (onInvalid === "dlq" && !deadLetterHandler) {
+    throw new Error(
+      "deadLetterHandler is required when onInvalid is set to 'dlq'"
+    );
+  }
+  const excludeSet = new Set(excludeTypes);
+  return async (ctx, next) => {
+    const { envelope } = ctx;
+    const messageType = envelope.type;
+    if (excludeSet.has(messageType)) {
+      await next();
+      return;
+    }
+    const validator = validators[messageType];
+    if (!validator) {
+      if (strictMode) {
+        const errors = [
+          {
+            path: "type",
+            message: `No validator registered for message type: ${messageType}`
+          }
+        ];
+        await handleInvalidMessage(
+          ctx,
+          errors,
+          onInvalid,
+          deadLetterHandler,
+          logger
+        );
+        return;
+      }
+      await next();
+      return;
+    }
+    const result = await validator(envelope.payload);
+    if (result.valid) {
+      await next();
+      return;
+    }
+    await handleInvalidMessage(
+      ctx,
+      result.errors || [],
+      onInvalid,
+      deadLetterHandler,
+      logger
+    );
+  };
+}
+async function handleInvalidMessage(ctx, errors, onInvalid, deadLetterHandler, logger) {
+  const { envelope } = ctx;
+  switch (onInvalid) {
+    case "throw":
+      throw new MessageValidationError(envelope.id, envelope.type, errors);
+    case "dlq":
+      logger?.error("Invalid message, sending to DLQ", {
+        messageId: envelope.id,
+        messageType: envelope.type,
+        correlationId: ctx.correlationId,
+        sagaName: ctx.sagaName,
+        errors
+      });
+      await deadLetterHandler(envelope, errors);
+      break;
+    case "log":
+      logger?.warn("Invalid message detected, skipping", {
+        messageId: envelope.id,
+        messageType: envelope.type,
+        correlationId: ctx.correlationId,
+        sagaName: ctx.sagaName,
+        errors
+      });
+    // Fall through to skip
+    case "skip":
+    default:
+      break;
+  }
+}
+
+// src/validators/ZodValidator.ts
+function createZodValidator(schema) {
+  return (message) => {
+    const result = schema.safeParse(message);
+    if (result.success) {
+      return { valid: true };
+    }
+    const errors = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }));
+    return { valid: false, errors };
+  };
+}
+function createZodValidators(schemas) {
+  const validators = {};
+  for (const [type, schema] of Object.entries(schemas)) {
+    validators[type] = createZodValidator(schema);
+  }
+  return validators;
+}
+
+// src/validators/FunctionValidator.ts
+function createFunctionValidator(fn) {
+  return async (message) => {
+    const result = await fn(message);
+    if (result === true) {
+      return { valid: true };
+    }
+    const errors = [];
+    if (result === false) {
+      errors.push({ path: "", message: "Validation failed" });
+    } else if (typeof result === "string") {
+      errors.push({ path: "", message: result });
+    } else if (Array.isArray(result)) {
+      for (const msg of result) {
+        errors.push({ path: "", message: msg });
+      }
+    }
+    return { valid: false, errors };
+  };
+}
+function combineValidators(validators) {
+  return async (message) => {
+    const allErrors = [];
+    for (const validator of validators) {
+      const result = await validator(message);
+      if (!result.valid && result.errors) {
+        allErrors.push(...result.errors);
+      }
+    }
+    if (allErrors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors: allErrors };
+  };
+}
+export {
+  MessageValidationError,
+  combineValidators,
+  createFunctionValidator,
+  createValidationMiddleware,
+  createZodValidator,
+  createZodValidators
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/ValidationMiddleware.ts","../src/validators/ZodValidator.ts","../src/validators/FunctionValidator.ts"],"sourcesContent":["import type { MessageEnvelope, BaseMessage } from \"@saga-bus/core\";\n\n/**\n * Result of a validation.\n */\nexport interface ValidationResult {\n  /** Whether the validation passed */\n  valid: boolean;\n  /** Validation errors if invalid */\n  errors?: ValidationError[];\n}\n\n/**\n * A single validation error.\n */\nexport interface ValidationError {\n  /** Path to the invalid field (e.g., \"payload.items[0].quantity\") */\n  path: string;\n  /** Error message */\n  message: string;\n  /** The invalid value */\n  value?: unknown;\n}\n\n/**\n * A synchronous validator function that validates a message.\n */\nexport type SyncMessageValidator<T extends BaseMessage = BaseMessage> = (\n  message: T\n) => ValidationResult;\n\n/**\n * An asynchronous validator function that validates a message.\n */\nexport type AsyncMessageValidator<T extends BaseMessage = BaseMessage> = (\n  message: T\n) => Promise<ValidationResult>;\n\n/**\n * A validator function that validates a message (sync or async).\n */\nexport type MessageValidator<T extends BaseMessage = BaseMessage> = (\n  message: T\n) => ValidationResult | Promise<ValidationResult>;\n\n/**\n * Action to take when validation fails.\n */\nexport type InvalidMessageAction = \"skip\" | \"log\" | \"throw\" | \"dlq\";\n\n/**\n * Dead-letter queue handler for invalid messages.\n */\nexport type DeadLetterHandler = (\n  envelope: MessageEnvelope,\n  errors: ValidationError[]\n) => Promise<void>;\n\n/**\n * A validator that can be used in the middleware (accepts any message type).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyMessageValidator = (message: any) => ValidationResult | Promise<ValidationResult>;\n\n/**\n * Options for the validation middleware.\n */\nexport interface ValidationMiddlewareOptions {\n  /**\n   * Map of message type to validator.\n   * Messages without a registered validator will pass through.\n   */\n  validators: Record<string, AnyMessageValidator>;\n\n  /**\n   * Action to take when validation fails.\n   * - \"skip\": Silently skip processing\n   * - \"log\": Log warning and skip\n   * - \"throw\": Throw a ValidationError\n   * - \"dlq\": Send to dead-letter queue handler\n   * @default \"throw\"\n   */\n  onInvalid?: InvalidMessageAction;\n\n  /**\n   * Handler for dead-letter queue (required if onInvalid is \"dlq\").\n   */\n  deadLetterHandler?: DeadLetterHandler;\n\n  /**\n   * Custom logger for validation errors.\n   */\n  logger?: {\n    warn(message: string, meta?: Record<string, unknown>): void;\n    error(message: string, meta?: Record<string, unknown>): void;\n  };\n\n  /**\n   * Whether to validate messages that don't have a registered validator.\n   * If true, messages without validators will be rejected.\n   * @default false\n   */\n  strictMode?: boolean;\n\n  /**\n   * Message types that should not be validated.\n   */\n  excludeTypes?: string[];\n}\n\n/**\n * Error thrown when validation fails and onInvalid is \"throw\".\n */\nexport class MessageValidationError extends Error {\n  public readonly messageId: string;\n  public readonly messageType: string;\n  public readonly validationErrors: ValidationError[];\n\n  constructor(\n    messageId: string,\n    messageType: string,\n    errors: ValidationError[]\n  ) {\n    const errorSummary = errors\n      .map((e) => `${e.path}: ${e.message}`)\n      .join(\", \");\n    super(`Validation failed for message ${messageId}: ${errorSummary}`);\n    this.name = \"MessageValidationError\";\n    this.messageId = messageId;\n    this.messageType = messageType;\n    this.validationErrors = errors;\n  }\n}\n","import type { SagaMiddleware, SagaPipelineContext } from \"@saga-bus/core\";\nimport type { ValidationMiddlewareOptions, ValidationError } from \"./types.js\";\nimport { MessageValidationError } from \"./types.js\";\n\n/**\n * Creates validation middleware that validates message payloads before processing.\n *\n * @example\n * ```typescript\n * import { createValidationMiddleware, createZodValidator } from \"@saga-bus/middleware-validation\";\n * import { z } from \"zod\";\n *\n * const validationMiddleware = createValidationMiddleware({\n *   validators: {\n *     OrderCreated: createZodValidator(z.object({\n *       type: z.literal(\"OrderCreated\"),\n *       orderId: z.string(),\n *       customerId: z.string(),\n *     })),\n *   },\n *   onInvalid: \"throw\",\n * });\n *\n * const bus = createBus({\n *   transport,\n *   store,\n *   sagas: [MySaga],\n *   middleware: [validationMiddleware],\n * });\n * ```\n */\nexport function createValidationMiddleware(\n  options: ValidationMiddlewareOptions\n): SagaMiddleware {\n  const {\n    validators,\n    onInvalid = \"throw\",\n    deadLetterHandler,\n    logger,\n    strictMode = false,\n    excludeTypes = [],\n  } = options;\n\n  // Validate options\n  if (onInvalid === \"dlq\" && !deadLetterHandler) {\n    throw new Error(\n      \"deadLetterHandler is required when onInvalid is set to 'dlq'\"\n    );\n  }\n\n  const excludeSet = new Set(excludeTypes);\n\n  return async (ctx: SagaPipelineContext, next: () => Promise<void>) => {\n    const { envelope } = ctx;\n    const messageType = envelope.type;\n\n    // Skip excluded types\n    if (excludeSet.has(messageType)) {\n      await next();\n      return;\n    }\n\n    // Get validator for this message type\n    const validator = validators[messageType];\n\n    // Handle missing validator\n    if (!validator) {\n      if (strictMode) {\n        const errors: ValidationError[] = [\n          {\n            path: \"type\",\n            message: `No validator registered for message type: ${messageType}`,\n          },\n        ];\n        await handleInvalidMessage(\n          ctx,\n          errors,\n          onInvalid,\n          deadLetterHandler,\n          logger\n        );\n        return;\n      }\n      // Not strict mode - pass through\n      await next();\n      return;\n    }\n\n    // Validate the message payload\n    const result = await validator(envelope.payload);\n\n    if (result.valid) {\n      await next();\n      return;\n    }\n\n    // Handle invalid message\n    await handleInvalidMessage(\n      ctx,\n      result.errors || [],\n      onInvalid,\n      deadLetterHandler,\n      logger\n    );\n  };\n}\n\nasync function handleInvalidMessage(\n  ctx: SagaPipelineContext,\n  errors: ValidationError[],\n  onInvalid: string,\n  deadLetterHandler: ((envelope: typeof ctx.envelope, errors: ValidationError[]) => Promise<void>) | undefined,\n  logger: { warn(message: string, meta?: Record<string, unknown>): void; error(message: string, meta?: Record<string, unknown>): void } | undefined\n): Promise<void> {\n  const { envelope } = ctx;\n\n  switch (onInvalid) {\n    case \"throw\":\n      throw new MessageValidationError(envelope.id, envelope.type, errors);\n\n    case \"dlq\":\n      logger?.error(\"Invalid message, sending to DLQ\", {\n        messageId: envelope.id,\n        messageType: envelope.type,\n        correlationId: ctx.correlationId,\n        sagaName: ctx.sagaName,\n        errors,\n      });\n      await deadLetterHandler!(envelope, errors);\n      break;\n\n    case \"log\":\n      logger?.warn(\"Invalid message detected, skipping\", {\n        messageId: envelope.id,\n        messageType: envelope.type,\n        correlationId: ctx.correlationId,\n        sagaName: ctx.sagaName,\n        errors,\n      });\n      // Fall through to skip\n\n    case \"skip\":\n    default:\n      // Don't call next() - silently skip processing\n      break;\n  }\n}\n","import type { BaseMessage } from \"@saga-bus/core\";\nimport type { SyncMessageValidator, ValidationResult, ValidationError, AnyMessageValidator } from \"../types.js\";\n\n// Type for Zod schema - we don't import zod directly to keep it optional\ninterface ZodSchema {\n  safeParse(data: unknown): {\n    success: boolean;\n    data?: unknown;\n    error?: {\n      issues: Array<{\n        path: (string | number)[];\n        message: string;\n      }>;\n    };\n  };\n}\n\n/**\n * Creates a validator from a Zod schema.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { createZodValidator } from \"@saga-bus/middleware-validation\";\n *\n * const OrderCreatedSchema = z.object({\n *   type: z.literal(\"OrderCreated\"),\n *   orderId: z.string().uuid(),\n *   customerId: z.string(),\n *   items: z.array(z.object({\n *     sku: z.string(),\n *     quantity: z.number().positive(),\n *   })),\n *   total: z.number().nonnegative(),\n * });\n *\n * const validator = createZodValidator(OrderCreatedSchema);\n * ```\n */\nexport function createZodValidator<T extends BaseMessage = BaseMessage>(schema: ZodSchema): SyncMessageValidator<T> {\n  return (message: T): ValidationResult => {\n    const result = schema.safeParse(message);\n\n    if (result.success) {\n      return { valid: true };\n    }\n\n    const errors: ValidationError[] = result.error!.issues.map((issue) => ({\n      path: issue.path.join(\".\"),\n      message: issue.message,\n    }));\n\n    return { valid: false, errors };\n  };\n}\n\n/**\n * Creates multiple validators from a map of Zod schemas.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { createZodValidators } from \"@saga-bus/middleware-validation\";\n *\n * const validators = createZodValidators({\n *   OrderCreated: z.object({\n *     type: z.literal(\"OrderCreated\"),\n *     orderId: z.string(),\n *   }),\n *   OrderShipped: z.object({\n *     type: z.literal(\"OrderShipped\"),\n *     orderId: z.string(),\n *     trackingNumber: z.string(),\n *   }),\n * });\n * ```\n */\nexport function createZodValidators(\n  schemas: Record<string, ZodSchema>\n): Record<string, AnyMessageValidator> {\n  const validators: Record<string, AnyMessageValidator> = {};\n\n  for (const [type, schema] of Object.entries(schemas)) {\n    validators[type] = createZodValidator(schema);\n  }\n\n  return validators;\n}\n","import type { BaseMessage } from \"@saga-bus/core\";\nimport type {\n  MessageValidator,\n  ValidationResult,\n  ValidationError,\n} from \"../types.js\";\n\n/**\n * A simple validation function that returns true/false or an error message.\n */\nexport type SimpleValidationFn<T> = (\n  message: T\n) => boolean | string | string[] | Promise<boolean | string | string[]>;\n\n/**\n * Creates a validator from a simple validation function.\n *\n * @example\n * ```typescript\n * import { createFunctionValidator } from \"@saga-bus/middleware-validation\";\n *\n * const validator = createFunctionValidator((message: OrderCreated) => {\n *   if (!message.orderId) {\n *     return \"orderId is required\";\n *   }\n *   if (message.items.length === 0) {\n *     return \"Order must have at least one item\";\n *   }\n *   return true;\n * });\n * ```\n */\nexport function createFunctionValidator<T extends BaseMessage = BaseMessage>(\n  fn: SimpleValidationFn<T>\n): MessageValidator<T> {\n  return async (message: T): Promise<ValidationResult> => {\n    const result = await fn(message);\n\n    if (result === true) {\n      return { valid: true };\n    }\n\n    const errors: ValidationError[] = [];\n\n    if (result === false) {\n      errors.push({ path: \"\", message: \"Validation failed\" });\n    } else if (typeof result === \"string\") {\n      errors.push({ path: \"\", message: result });\n    } else if (Array.isArray(result)) {\n      for (const msg of result) {\n        errors.push({ path: \"\", message: msg });\n      }\n    }\n\n    return { valid: false, errors };\n  };\n}\n\n/**\n * Combines multiple validators into one.\n * All validators must pass for the message to be valid.\n *\n * @example\n * ```typescript\n * import { combineValidators, createFunctionValidator } from \"@saga-bus/middleware-validation\";\n *\n * const validator = combineValidators([\n *   createFunctionValidator((msg) => !!msg.orderId || \"orderId required\"),\n *   createFunctionValidator((msg) => msg.items.length > 0 || \"items required\"),\n * ]);\n * ```\n */\nexport function combineValidators<T extends BaseMessage = BaseMessage>(\n  validators: MessageValidator<T>[]\n): MessageValidator<T> {\n  return async (message: T): Promise<ValidationResult> => {\n    const allErrors: ValidationError[] = [];\n\n    for (const validator of validators) {\n      const result = await validator(message);\n      if (!result.valid && result.errors) {\n        allErrors.push(...result.errors);\n      }\n    }\n\n    if (allErrors.length === 0) {\n      return { valid: true };\n    }\n\n    return { valid: false, errors: allErrors };\n  };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@saga-bus/middleware-validation",
+  "version": "0.1.0",
+  "description": "Validation middleware for saga-bus message payload validation",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@saga-bus/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "zod": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.0.0",
+    "zod": "^3.24.0",
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "keywords": [
+    "saga",
+    "saga-bus",
+    "middleware",
+    "validation",
+    "zod",
+    "schema",
+    "event-sourcing"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}