@morojs/moro 1.3.0 → 1.4.0

package/src/core/validation/adapters.ts

@@ -0,0 +1,147 @@
+// Validation Library Adapters for Moro Framework
+// Makes Joi, Yup, and other libraries compatible with ValidationSchema interface
+
+import { ValidationSchema, ValidationError, normalizeValidationError } from './schema-interface';
+
+/**
+ * Zod Compatibility Check
+ * Zod ALREADY implements ValidationSchema interface natively!
+ * No adapter needed - it just works.
+ */
+
+/**
+ * Joi Adapter - makes Joi schemas compatible with ValidationSchema
+ */
+export class JoiAdapter<T = any> implements ValidationSchema<T> {
+  constructor(private joiSchema: any) {
+    if (!joiSchema || typeof joiSchema.validateAsync !== 'function') {
+      throw new Error('Invalid Joi schema provided to JoiAdapter');
+    }
+  }
+
+  async parseAsync(data: unknown): Promise<T> {
+    try {
+      const result = await this.joiSchema.validateAsync(data, { abortEarly: false });
+      return result as T;
+    } catch (error) {
+      throw normalizeValidationError(error);
+    }
+  }
+}
+
+/**
+ * Yup Adapter - makes Yup schemas compatible with ValidationSchema
+ */
+export class YupAdapter<T = any> implements ValidationSchema<T> {
+  constructor(private yupSchema: any) {
+    if (!yupSchema || typeof yupSchema.validate !== 'function') {
+      throw new Error('Invalid Yup schema provided to YupAdapter');
+    }
+  }
+
+  async parseAsync(data: unknown): Promise<T> {
+    try {
+      const result = await this.yupSchema.validate(data, { abortEarly: false });
+      return result as T;
+    } catch (error) {
+      throw normalizeValidationError(error);
+    }
+  }
+}
+
+/**
+ * Custom Validation Function Adapter
+ * Allows users to use simple validation functions
+ */
+export class FunctionAdapter<T = any> implements ValidationSchema<T> {
+  constructor(
+    private validateFn: (data: unknown) => T | Promise<T>,
+    private name: string = 'custom'
+  ) {
+    if (typeof validateFn !== 'function') {
+      throw new Error('Validation function is required for FunctionAdapter');
+    }
+  }
+
+  async parseAsync(data: unknown): Promise<T> {
+    try {
+      return await this.validateFn(data);
+    } catch (error) {
+      throw new ValidationError([
+        {
+          path: [],
+          message: error instanceof Error ? error.message : String(error),
+          code: this.name,
+        },
+      ]);
+    }
+  }
+}
+
+/**
+ * Class Validator Adapter (for TypeScript decorators)
+ */
+export class ClassValidatorAdapter<T extends object = any> implements ValidationSchema<T> {
+  constructor(
+    private ClassType: new () => T,
+    private validate?: (obj: any) => Promise<any[]>
+  ) {
+    if (typeof ClassType !== 'function') {
+      throw new Error('Class constructor is required for ClassValidatorAdapter');
+    }
+  }
+
+  async parseAsync(data: unknown): Promise<T> {
+    try {
+      const instance = Object.assign(new this.ClassType(), data as Record<string, any>);
+
+      if (this.validate) {
+        const errors = await this.validate(instance);
+        if (errors && errors.length > 0) {
+          throw new ValidationError(
+            errors.map((error: any, index: number) => ({
+              path: error.property ? [error.property] : [index],
+              message: Object.values(error.constraints || {}).join(', ') || 'Validation failed',
+              code: 'class_validator',
+            }))
+          );
+        }
+      }
+
+      return instance as T;
+    } catch (error) {
+      if (error instanceof ValidationError) throw error;
+      throw normalizeValidationError(error);
+    }
+  }
+}
+
+/**
+ * Utility functions for creating adapters
+ */
+export function joi<T = any>(joiSchema: any): ValidationSchema<T> {
+  return new JoiAdapter<T>(joiSchema);
+}
+
+export function yup<T = any>(yupSchema: any): ValidationSchema<T> {
+  return new YupAdapter<T>(yupSchema);
+}
+
+export function fn<T = any>(
+  validateFn: (data: unknown) => T | Promise<T>,
+  name?: string
+): ValidationSchema<T> {
+  return new FunctionAdapter<T>(validateFn, name);
+}
+
+export function classValidator<T extends object = any>(
+  ClassType: new () => T,
+  validate?: (obj: any) => Promise<any[]>
+): ValidationSchema<T> {
+  return new ClassValidatorAdapter<T>(ClassType, validate);
+}
+
+// Type helpers
+export type JoiSchema<T> = ValidationSchema<T>;
+export type YupSchema<T> = ValidationSchema<T>;
+export type CustomValidator<T> = ValidationSchema<T>;

package/src/core/validation/index.ts

@@ -1,28 +1,41 @@
-// Functional Validation System for Moro Framework
-// Elegant, type-safe validation using Zod with functional composition
+// Universal Validation System for Moro Framework
+// Works with Zod, Joi, Yup, and any validation library via adapters
 
-import { z, ZodSchema, ZodError } from 'zod';
 import { HttpRequest, HttpResponse } from '../http';
 import { createFrameworkLogger } from '../logger';
+import {
+  ValidationSchema,
+  ValidationError,
+  normalizeValidationError,
+  InferSchemaType,
+} from './schema-interface';
+
+// Re-export zod if available (for backward compatibility)
+let z: any;
+try {
+  z = require('zod').z;
+} catch {
+  // Zod not available - that's fine!
+}
 
 const logger = createFrameworkLogger('Validation');
 
-// Validation configuration interface
+// Universal validation configuration interface
 export interface ValidationConfig {
-  body?: ZodSchema;
-  query?: ZodSchema;
-  params?: ZodSchema;
-  headers?: ZodSchema;
+  body?: ValidationSchema;
+  query?: ValidationSchema;
+  params?: ValidationSchema;
+  headers?: ValidationSchema;
 }
 
 // Validation result types
 export interface ValidationResult<T = any> {
   success: boolean;
   data?: T;
-  errors?: ValidationError[];
+  errors?: ValidationErrorDetail[];
 }
 
-export interface ValidationError {
+export interface ValidationErrorDetail {
   field: string;
   message: string;
   code: string;
@@ -110,9 +123,9 @@ export function validate<TBody = any, TQuery = any, TParams = any>(
   };
 }
 
-// Validate individual field
+// Validate individual field using universal schema interface
 async function validateField(
-  schema: ZodSchema,
+  schema: ValidationSchema,
   data: any,
   fieldName: string
 ): Promise<ValidationResult> {
@@ -123,32 +136,32 @@ async function validateField(
       data: validated,
     };
   } catch (error) {
-    if (error instanceof ZodError) {
-      const errors: ValidationError[] = error.issues.map((err: any) => ({
-        field: err.path.length > 0 ? err.path.join('.') : fieldName,
-        message: err.message,
-        code: err.code,
-      }));
-
-      logger.debug('Field validation failed', 'ValidationFailed', {
-        field: fieldName,
-        errors: errors.length,
-        details: errors,
-      });
-
-      return {
-        success: false,
-        errors,
-      };
-    }
+    const normalizedError = normalizeValidationError(error);
+    const errors: ValidationErrorDetail[] = normalizedError.issues.map(issue => ({
+      field: issue.path.length > 0 ? issue.path.join('.') : fieldName,
+      message: issue.message,
+      code: issue.code,
+    }));
+
+    logger.debug('Field validation failed', 'ValidationFailed', {
+      field: fieldName,
+      errors: errors.length,
+      details: errors,
+    });
 
-    // Re-throw unexpected errors
-    throw error;
+    return {
+      success: false,
+      errors,
+    };
   }
 }
 
 // Send validation error response
-function sendValidationError(res: HttpResponse, errors: ValidationError[], field: string): void {
+function sendValidationError(
+  res: HttpResponse,
+  errors: ValidationErrorDetail[],
+  field: string
+): void {
   logger.debug('Sending validation error response', 'ValidationResponse', {
     field,
     errorCount: errors.length,
@@ -163,19 +176,19 @@ function sendValidationError(res: HttpResponse, errors: ValidationError[], field
 }
 
 // Convenience functions for single-field validation
-export function body<T>(schema: ZodSchema<T>) {
+export function body<T>(schema: ValidationSchema<T>) {
   return (handler: (req: ValidatedRequest<T>, res: HttpResponse) => any | Promise<any>) => {
     return validate({ body: schema }, handler);
   };
 }
 
-export function query<T>(schema: ZodSchema<T>) {
+export function query<T>(schema: ValidationSchema<T>) {
   return (handler: (req: ValidatedRequest<any>, res: HttpResponse) => any | Promise<any>) => {
     return validate({ query: schema }, handler);
   };
 }
 
-export function params<T>(schema: ZodSchema<T>) {
+export function params<T>(schema: ValidationSchema<T>) {
   return (handler: (req: ValidatedRequest<any>, res: HttpResponse) => any | Promise<any>) => {
     return validate({ params: schema }, handler);
   };
@@ -186,5 +199,14 @@ export function combineSchemas(schemas: ValidationConfig): ValidationConfig {
   return schemas;
 }
 
-// Re-export Zod for convenience
-export { z } from 'zod';
+// Re-export common validation tools
+export {
+  ValidationSchema,
+  ValidationError,
+  normalizeValidationError,
+  InferSchemaType,
+} from './schema-interface';
+export { joi, yup, fn as customValidator, classValidator } from './adapters';
+
+// Re-export Zod if available (optional dependency)
+export { z };

package/src/core/validation/schema-interface.ts

@@ -0,0 +1,100 @@
+// Universal Validation Schema Interface for Moro Framework
+// Allows Zod, Joi, Yup, and other validation libraries to work seamlessly
+
+/**
+ * Standard validation error structure
+ */
+export interface ValidationIssue {
+  path: (string | number)[];
+  message: string;
+  code: string;
+}
+
+/**
+ * Standard validation error class
+ * Compatible with ZodError structure
+ */
+export class ValidationError extends Error {
+  public readonly issues: ValidationIssue[];
+
+  constructor(issues: ValidationIssue[]) {
+    const message = `Validation failed: ${issues.map(i => i.message).join(', ')}`;
+    super(message);
+    this.name = 'ValidationError';
+    this.issues = issues;
+  }
+}
+
+/**
+ * Universal validation schema interface
+ * This is what Zod naturally implements! No breaking changes needed.
+ */
+export interface ValidationSchema<T = any> {
+  /**
+   * Parse data asynchronously and return validated result
+   * Throws ValidationError on validation failure
+   */
+  parseAsync(data: unknown): Promise<T>;
+}
+
+/**
+ * Check if an object implements the ValidationSchema interface
+ */
+export function isValidationSchema(obj: any): obj is ValidationSchema {
+  return obj && typeof obj.parseAsync === 'function';
+}
+
+/**
+ * Convert various error formats to our standard ValidationError
+ */
+export function normalizeValidationError(error: any): ValidationError {
+  // Already our format
+  if (error instanceof ValidationError) {
+    return error;
+  }
+
+  // Zod error format
+  if (error && error.issues && Array.isArray(error.issues)) {
+    return new ValidationError(
+      error.issues.map((issue: any) => ({
+        path: issue.path || [],
+        message: issue.message || 'Validation failed',
+        code: issue.code || 'invalid',
+      }))
+    );
+  }
+
+  // Joi error format
+  if (error && error.details && Array.isArray(error.details)) {
+    return new ValidationError(
+      error.details.map((detail: any) => ({
+        path: detail.path || [],
+        message: detail.message || 'Validation failed',
+        code: detail.type || 'invalid',
+      }))
+    );
+  }
+
+  // Yup error format
+  if (error && error.errors && Array.isArray(error.errors)) {
+    return new ValidationError(
+      error.errors.map((msg: string, index: number) => ({
+        path: error.path ? [error.path] : [index],
+        message: msg,
+        code: error.type || 'invalid',
+      }))
+    );
+  }
+
+  // Generic error
+  return new ValidationError([
+    {
+      path: [],
+      message: error.message || String(error),
+      code: 'unknown',
+    },
+  ]);
+}
+
+// Type helper for inferring types from validation schemas
+export type InferSchemaType<T> = T extends ValidationSchema<infer U> ? U : never;

package/src/index.ts

@@ -105,15 +105,24 @@ export type {
 // Logger System
 export { createFrameworkLogger, logger } from './core/logger';
 
-// Validation System (Zod-based)
+// Universal Validation System
 export { validate, body, query, params, combineSchemas, z } from './core/validation';
 export type {
   ValidationConfig,
   ValidationResult,
-  ValidationError,
+  ValidationErrorDetail,
   ValidatedRequest,
 } from './core/validation';
 
+// Universal Validation Interfaces and Adapters
+export type {
+  ValidationSchema,
+  ValidationError,
+  InferSchemaType,
+} from './core/validation/schema-interface';
+export { normalizeValidationError } from './core/validation/schema-interface';
+export { joi, yup, fn as customValidator, classValidator } from './core/validation/adapters';
+
 // Module System
 export {
   defineModule,
@@ -123,6 +132,20 @@ export {
 } from './core/modules';
 export type { ModuleDefinition, ModuleRoute, ModuleSocket, ModuleConfig } from './types/module';
 
+// WebSocket Adapter System
+export type {
+  WebSocketAdapter,
+  WebSocketAdapterOptions,
+  WebSocketNamespace,
+  WebSocketConnection,
+  WebSocketEmitter,
+  WebSocketMiddleware,
+  WebSocketEventHandler,
+} from './core/networking/websocket-adapter';
+
+// Built-in WebSocket Adapters
+export { SocketIOAdapter, WSAdapter } from './core/networking/adapters';
+
 // Intelligent Routing System
 export { createRoute, defineRoute, EXECUTION_PHASES } from './core/routing';
 export { IntelligentRoutingManager, RouteRegistry } from './core/routing/app-integration';

package/src/moro.ts

@@ -387,10 +387,19 @@ export class Moro extends EventEmitter {
 
   // WebSocket helper with events
   websocket(namespace: string, handlers: Record<string, Function>) {
+    const adapter = this.coreFramework.getWebSocketAdapter();
+    if (!adapter) {
+      throw new Error(
+        'WebSocket features require a WebSocket adapter. Install socket.io or configure an adapter:\n' +
+          'npm install socket.io\n' +
+          'or\n' +
+          'new Moro({ websocket: { adapter: new SocketIOAdapter() } })'
+      );
+    }
+
     this.emit('websocket:registering', { namespace, handlers });
 
-    const io = this.coreFramework.getIOServer();
-    const ns = io.of(namespace);
+    const ns = adapter.createNamespace(namespace);
 
     Object.entries(handlers).forEach(([event, handler]) => {
       ns.on('connection', socket => {