@morojs/moro 1.3.0 → 1.5.0

package/src/core/docs/schema-to-openapi.ts

@@ -0,0 +1,148 @@
+// Universal Schema to OpenAPI Converter
+// Converts ValidationSchema (Zod, Joi, etc.) to OpenAPI 3.0 schema definitions
+
+import { ValidationSchema } from '../validation/schema-interface';
+import { OpenAPISchema } from './zod-to-openapi';
+import { createFrameworkLogger } from '../logger';
+
+const logger = createFrameworkLogger('SchemaToOpenAPI');
+
+// Check if a schema is a Zod schema
+function isZodSchema(schema: any): boolean {
+  return (
+    schema && typeof schema === 'object' && schema._def && typeof schema.parseAsync === 'function'
+  );
+}
+
+// Check if schema is Joi
+function isJoiSchema(schema: any): boolean {
+  return (
+    schema &&
+    typeof schema === 'object' &&
+    schema.type &&
+    typeof schema.validateAsync === 'function'
+  );
+}
+
+// Convert any ValidationSchema to OpenAPI
+export function schemaToOpenAPI(
+  schema: ValidationSchema,
+  options: { includeExamples?: boolean; includeDescriptions?: boolean } = {}
+): OpenAPISchema {
+  // If it's a Zod schema, use the existing zod converter
+  if (isZodSchema(schema)) {
+    try {
+      // Import zod converter dynamically
+      const { zodToOpenAPI } = require('./zod-to-openapi');
+      return zodToOpenAPI(schema, options);
+    } catch (error) {
+      logger.warn('Zod converter not available, using fallback', String(error));
+    }
+  }
+
+  // If it's a Joi schema, convert from Joi
+  if (isJoiSchema(schema)) {
+    return convertJoiToOpenAPI(schema as any, options);
+  }
+
+  // For other schemas (custom validators, etc.), return a generic object schema
+  logger.debug('Using generic schema conversion for unknown validation type');
+  return {
+    type: 'object',
+    description: options.includeDescriptions ? 'Validated object' : undefined,
+    additionalProperties: true,
+  };
+}
+
+// Generate example from any ValidationSchema
+export function generateExampleFromValidationSchema(schema: ValidationSchema): any {
+  // If it's a Zod schema, use existing example generator
+  if (isZodSchema(schema)) {
+    try {
+      const { generateExampleFromSchema } = require('./zod-to-openapi');
+      return generateExampleFromSchema(schema);
+    } catch (error) {
+      logger.warn('Zod example generator not available', String(error));
+    }
+  }
+
+  // For other schemas, return a generic example
+  return {
+    example: 'Validated data structure',
+  };
+}
+
+// Convert Joi schema to OpenAPI (basic implementation)
+function convertJoiToOpenAPI(
+  joiSchema: any,
+  options: { includeDescriptions?: boolean }
+): OpenAPISchema {
+  const schemaType = joiSchema.type;
+
+  switch (schemaType) {
+    case 'string':
+      return {
+        type: 'string',
+        description: options.includeDescriptions ? joiSchema._description : undefined,
+        minLength: joiSchema._rules?.find((r: any) => r.name === 'min')?.args?.limit,
+        maxLength: joiSchema._rules?.find((r: any) => r.name === 'max')?.args?.limit,
+        pattern: joiSchema._rules?.find((r: any) => r.name === 'pattern')?.args?.regex?.source,
+      };
+
+    case 'number':
+      return {
+        type: 'number',
+        description: options.includeDescriptions ? joiSchema._description : undefined,
+        minimum: joiSchema._rules?.find((r: any) => r.name === 'min')?.args?.limit,
+        maximum: joiSchema._rules?.find((r: any) => r.name === 'max')?.args?.limit,
+      };
+
+    case 'boolean':
+      return {
+        type: 'boolean',
+        description: options.includeDescriptions ? joiSchema._description : undefined,
+      };
+
+    case 'object': {
+      const properties: Record<string, OpenAPISchema> = {};
+      const required: string[] = [];
+
+      if (joiSchema._inner?.children) {
+        for (const child of joiSchema._inner.children) {
+          const key = child.key;
+          properties[key] = convertJoiToOpenAPI(child.schema, options);
+
+          if (child.schema._flags?.presence === 'required') {
+            required.push(key);
+          }
+        }
+      }
+
+      return {
+        type: 'object',
+        properties,
+        required: required.length > 0 ? required : undefined,
+        description: options.includeDescriptions ? joiSchema._description : undefined,
+      };
+    }
+
+    case 'array':
+      return {
+        type: 'array',
+        items: joiSchema._inner?.items?.[0]
+          ? convertJoiToOpenAPI(joiSchema._inner.items[0], options)
+          : { type: 'object' },
+        description: options.includeDescriptions ? joiSchema._description : undefined,
+        minItems: joiSchema._rules?.find((r: any) => r.name === 'min')?.args?.limit,
+        maxItems: joiSchema._rules?.find((r: any) => r.name === 'max')?.args?.limit,
+      };
+
+    default:
+      logger.warn(`Unsupported Joi schema type: ${schemaType}`);
+      return {
+        type: 'object',
+        additionalProperties: true,
+        description: options.includeDescriptions ? 'Complex validation schema' : undefined,
+      };
+  }
+}

package/src/core/docs/simple-docs.ts

@@ -132,7 +132,7 @@ export class SimpleDocsGenerator {
   <div class="container">
     <h1>${this.options.title}</h1>
     <p>${this.options.description}</p>
-    
+
     <div class="example">
       <strong>Interactive Swagger UI:</strong> <a href="${this.options.basePath}" target="_blank">${this.options.basePath}</a><br>
       <strong>OpenAPI JSON:</strong> <a href="${this.options.basePath}/openapi.json" target="_blank">${this.options.basePath}/openapi.json</a>
@@ -189,11 +189,11 @@ export class SimpleDocsGenerator {
         <span class="method ${route.method}">${route.method}</span>
         <span class="path">${route.path}</span>
       </div>
-      
+
       ${route.description ? `<div class="description">${route.description}</div>` : ''}
-      
+
       ${route.tags ? `<div class="tags">${route.tags.map(tag => `<span class="tag">${tag}</span>`).join('')}</div>` : ''}
-      
+
       ${this.generateValidationInfo(route)}
       ${this.generateAuthInfo(route)}
       ${this.generateRateLimitInfo(route)}
@@ -215,7 +215,7 @@ export class SimpleDocsGenerator {
     return `
     <div class="validation">
       <strong>Validation:</strong> ${validationTypes.join(', ')}
-      <br><small>Request will be validated with Zod schemas for type safety</small>
+      <br><small>Request will be validated with Validation schemas for type safety</small>
     </div>`;
   }
 

package/src/core/docs/zod-to-openapi.ts

@@ -1,22 +1,40 @@
 // Zod to OpenAPI Schema Converter
 // Transforms Zod schemas into OpenAPI 3.0 schema definitions
 
-import {
-  ZodSchema,
-  ZodType,
-  ZodObject,
-  ZodArray,
-  ZodString,
-  ZodNumber,
-  ZodBoolean,
-  ZodEnum,
-  ZodOptional,
-  ZodDefault,
-  ZodUnion,
-  ZodLiteral,
-} from 'zod';
 import { createFrameworkLogger } from '../logger';
 
+// Dynamic Zod imports (optional dependency)
+let ZodSchema: any,
+  ZodType: any,
+  ZodObject: any,
+  ZodArray: any,
+  ZodString: any,
+  ZodNumber: any,
+  ZodBoolean: any,
+  ZodEnum: any,
+  ZodOptional: any,
+  ZodDefault: any,
+  ZodUnion: any,
+  ZodLiteral: any;
+
+try {
+  const zod = require('zod');
+  ZodSchema = zod.ZodSchema;
+  ZodType = zod.ZodType;
+  ZodObject = zod.ZodObject;
+  ZodArray = zod.ZodArray;
+  ZodString = zod.ZodString;
+  ZodNumber = zod.ZodNumber;
+  ZodBoolean = zod.ZodBoolean;
+  ZodEnum = zod.ZodEnum;
+  ZodOptional = zod.ZodOptional;
+  ZodDefault = zod.ZodDefault;
+  ZodUnion = zod.ZodUnion;
+  ZodLiteral = zod.ZodLiteral;
+} catch {
+  // Zod not available - that's fine!
+}
+
 const logger = createFrameworkLogger('ZodToOpenAPI');
 
 // OpenAPI schema types
@@ -33,6 +51,8 @@ export interface OpenAPISchema {
   maximum?: number;
   minLength?: number;
   maxLength?: number;
+  minItems?: number;
+  maxItems?: number;
   pattern?: string;
   default?: any;
   oneOf?: OpenAPISchema[];
@@ -50,7 +70,12 @@ export interface ConversionOptions {
 }
 
 // Main conversion function
-export function zodToOpenAPI(schema: ZodSchema, options: ConversionOptions = {}): OpenAPISchema {
+export function zodToOpenAPI(schema: any, options: ConversionOptions = {}): OpenAPISchema {
+  // Check if Zod is available
+  if (!ZodSchema) {
+    throw new Error('Zod is not installed. Please install zod to use zodToOpenAPI function.');
+  }
+
   const opts = {
     includeExamples: true,
     includeDescriptions: true,
@@ -365,7 +390,7 @@ function convertZodDefault(def: any, options: ConversionOptions): OpenAPISchema
 
 // Convert ZodUnion
 function convertZodUnion(def: any, options: ConversionOptions): OpenAPISchema {
-  const schemas = def.options.map((option: ZodType) => convertZodType(option._def, options));
+  const schemas = def.options.map((option: any) => convertZodType(option._def, options));
 
   return {
     oneOf: schemas,
@@ -384,16 +409,23 @@ function convertZodLiteral(def: any, options: ConversionOptions): OpenAPISchema
 }
 
 // Helper functions
-function isOptionalType(type: ZodType): boolean {
+function isOptionalType(type: any): boolean {
   return (type._def as any).typeName === 'ZodOptional';
 }
 
-function hasDefault(type: ZodType): boolean {
+function hasDefault(type: any): boolean {
   return (type._def as any).typeName === 'ZodDefault';
 }
 
 // Generate example data from Zod schema
-export function generateExampleFromSchema(schema: ZodSchema): any {
+export function generateExampleFromSchema(schema: any): any {
+  // Check if Zod is available
+  if (!ZodSchema) {
+    throw new Error(
+      'Zod is not installed. Please install zod to use generateExampleFromSchema function.'
+    );
+  }
+
   try {
     return generateExample(schema._def);
   } catch (error) {
@@ -439,7 +471,7 @@ function generateExample(def: any): any {
         }
 
         for (const [key, value] of Object.entries(shape)) {
-          const zodType = value as ZodType;
+          const zodType = value as any;
           if (!isOptionalType(zodType)) {
             example[key] = generateExample(zodType._def);
           }

package/src/core/framework.ts

@@ -1,10 +1,9 @@
-// src/core/framework.ts
+// Core Moro Framework with Pluggable WebSocket Adapters
 import { createServer, Server } from 'http';
 import {
   createSecureServer as createHttp2SecureServer,
   createServer as createHttp2Server,
 } from 'http2';
-import { Server as SocketIOServer } from 'socket.io';
 import { EventEmitter } from 'events';
 import { MoroHttpServer, HttpRequest, HttpResponse, middleware } from './http';
 import { Router } from './http';
@@ -16,6 +15,7 @@ import { MoroEventBus } from './events';
 import { createFrameworkLogger, logger as globalLogger } from './logger';
 import { ModuleConfig, InternalRouteDefinition } from '../types/module';
 import { LogLevel, LoggerOptions } from '../types/logger';
+import { WebSocketAdapter, WebSocketAdapterOptions } from './networking/websocket-adapter';
 
 export interface MoroOptions {
   http2?: boolean;
@@ -28,23 +28,27 @@ export interface MoroOptions {
     enabled?: boolean;
     threshold?: number;
   };
-  websocket?: {
-    compression?: boolean;
-    customIdGenerator?: () => string;
-  };
+  websocket?:
+    | {
+        enabled?: boolean;
+        adapter?: WebSocketAdapter;
+        compression?: boolean;
+        customIdGenerator?: () => string;
+        options?: WebSocketAdapterOptions;
+      }
+    | false;
   logger?: LoggerOptions | boolean;
 }
 
 export class Moro extends EventEmitter {
   private httpServer: MoroHttpServer;
   private server: Server | any; // HTTP/2 server type
-  private io: SocketIOServer;
+  private websocketAdapter?: WebSocketAdapter;
   private container: Container;
   private moduleLoader: ModuleLoader;
-  private websocketManager: WebSocketManager;
+  private websocketManager?: WebSocketManager;
   private circuitBreakers = new Map<string, CircuitBreaker>();
   private rateLimiters = new Map<string, Map<string, { count: number; resetTime: number }>>();
-  private ioInstance: SocketIOServer;
   // Enterprise-grade event system
   private eventBus: MoroEventBus;
   // Framework logger
@@ -99,23 +103,12 @@ export class Moro extends EventEmitter {
       this.server = this.httpServer.getServer();
     }
 
-    this.io = new SocketIOServer(this.server, {
-      cors: { origin: '*' },
-      path: '/socket.io/',
-    });
-
-    this.ioInstance = this.io;
     this.container = new Container();
     this.moduleLoader = new ModuleLoader(this.container);
-    this.websocketManager = new WebSocketManager(this.io, this.container);
-
-    // Configure WebSocket advanced features
-    if (options.websocket?.customIdGenerator) {
-      this.websocketManager.setCustomIdGenerator(options.websocket.customIdGenerator);
-    }
 
-    if (options.websocket?.compression) {
-      this.websocketManager.enableCompression();
+    // Setup WebSocket adapter if enabled
+    if (options.websocket !== false) {
+      this.setupWebSockets(options.websocket || {});
     }
 
     // Initialize enterprise event bus
@@ -153,6 +146,71 @@ export class Moro extends EventEmitter {
     this.httpServer.use(this.errorBoundaryMiddleware());
   }
 
+  /**
+   * Setup WebSocket adapter and manager
+   */
+  private async setupWebSockets(wsConfig: any): Promise<void> {
+    try {
+      // Use provided adapter or try to auto-detect
+      if (wsConfig.adapter) {
+        this.websocketAdapter = wsConfig.adapter;
+      } else {
+        this.websocketAdapter = (await this.detectWebSocketAdapter()) || undefined;
+      }
+
+      if (this.websocketAdapter) {
+        await this.websocketAdapter.initialize(this.server, wsConfig.options);
+        this.websocketManager = new WebSocketManager(this.websocketAdapter, this.container);
+
+        // Configure adapter features
+        if (wsConfig.compression) {
+          this.websocketAdapter.setCompression(true);
+        }
+        if (wsConfig.customIdGenerator) {
+          this.websocketAdapter.setCustomIdGenerator(wsConfig.customIdGenerator);
+        }
+
+        this.logger.info(
+          `WebSocket adapter initialized: ${this.websocketAdapter.getAdapterName()}`,
+          'WebSocketSetup'
+        );
+      }
+    } catch (error) {
+      this.logger.warn(
+        'WebSocket setup failed, continuing without WebSocket support',
+        'WebSocketSetup',
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  }
+
+  /**
+   * Auto-detect available WebSocket adapter
+   */
+  private async detectWebSocketAdapter(): Promise<WebSocketAdapter | null> {
+    // Try socket.io first
+    try {
+      const { SocketIOAdapter } = await import('./networking/adapters');
+      return new SocketIOAdapter();
+    } catch {
+      // socket.io not available
+    }
+
+    // Try native ws library
+    try {
+      const { WSAdapter } = await import('./networking/adapters');
+      return new WSAdapter();
+    } catch {
+      // ws not available
+    }
+
+    this.logger.warn(
+      'No WebSocket adapter found. Install socket.io or ws for WebSocket support',
+      'AdapterDetection'
+    );
+    return null;
+  }
+
   private requestTrackingMiddleware() {
     return (req: HttpRequest, res: HttpResponse, next: () => void) => {
       const startTime = Date.now();
@@ -206,8 +264,31 @@ export class Moro extends EventEmitter {
   }
 
   // Public API for accessing Socket.IO server
+  /**
+   * Get WebSocket adapter (for backward compatibility)
+   * @deprecated Use getWebSocketAdapter() instead
+   */
   getIOServer() {
-    return this.io;
+    if (!this.websocketAdapter) {
+      throw new Error(
+        'WebSocket adapter not available. Install socket.io or configure a WebSocket adapter.'
+      );
+    }
+    return this.websocketAdapter;
+  }
+
+  /**
+   * Get the WebSocket adapter
+   */
+  getWebSocketAdapter(): WebSocketAdapter | undefined {
+    return this.websocketAdapter;
+  }
+
+  /**
+   * Get the WebSocket manager
+   */
+  getWebSocketManager(): WebSocketManager | undefined {
+    return this.websocketManager;
   }
 
   async loadModule(moduleConfig: ModuleConfig): Promise<void> {
@@ -392,7 +473,7 @@ export class Moro extends EventEmitter {
               : undefined,
             events: moduleEventBus, // Use pre-created event bus
             app: {
-              get: (key: string) => (key === 'io' ? this.ioInstance : undefined),
+              get: (key: string) => (key === 'io' ? this.websocketAdapter : undefined),
             },
           };
           this.logger.debug(`Database available: ${!!requestToUse.database}`, 'Handler', {
@@ -466,7 +547,15 @@ export class Moro extends EventEmitter {
   }
 
   private async setupWebSocketHandlers(config: ModuleConfig): Promise<void> {
-    const namespace = this.io.of(`/${config.name}`);
+    if (!this.websocketAdapter || !this.websocketManager) {
+      this.logger.warn(
+        `Module ${config.name} defines WebSocket handlers but no WebSocket adapter is available`,
+        'WebSocketSetup'
+      );
+      return;
+    }
+
+    const namespace = this.websocketAdapter.createNamespace(`/${config.name}`);
 
     for (const wsConfig of config.websockets || []) {
       await this.websocketManager.registerHandler(namespace, wsConfig, config);
@@ -530,13 +619,17 @@ export class Moro extends EventEmitter {
   // Compatibility method for existing controllers
   set(key: string, value: any): void {
     if (key === 'io') {
-      this.ioInstance = value;
+      // Deprecated: Use websocket adapter instead
+      this.logger.warn(
+        'Setting io instance is deprecated. Use websocket adapter configuration.',
+        'Deprecated'
+      );
     }
   }
 
   get(key: string): any {
     if (key === 'io') {
-      return this.ioInstance;
+      return this.websocketAdapter;
     }
     return undefined;
   }

package/src/core/networking/adapters/index.ts

@@ -0,0 +1,16 @@
+// WebSocket Adapters for Moro Framework
+// Export all available adapters from this centralized location
+
+export { SocketIOAdapter } from './socketio-adapter';
+export { WSAdapter } from './ws-adapter';
+
+// Re-export the adapter interface for convenience
+export type {
+  WebSocketAdapter,
+  WebSocketAdapterOptions,
+  WebSocketNamespace,
+  WebSocketConnection,
+  WebSocketEmitter,
+  WebSocketMiddleware,
+  WebSocketEventHandler,
+} from '../websocket-adapter';