@morojs/moro 1.5.17 → 1.6.0

package/src/index.ts

@@ -7,9 +7,9 @@ export {
   createAppEdge,
   createAppLambda,
   createAppWorker,
-} from './moro';
+} from './moro.js';
 
-export type { MoroOptions } from './core/framework';
+export type { MoroOptions } from './core/framework.js';
 
 // Export auth types and middleware
 export type {
@@ -29,13 +29,13 @@ export type {
   EmailProvider,
   SignInOptions,
   SignOutOptions,
-} from './types/auth';
+} from './types/auth.js';
 
 // Export native @auth/morojs adapter
-export { createAuthMiddleware, MoroJSAuth } from './core/auth/morojs-adapter';
+export { createAuthMiddleware, MoroJSAuth } from './core/auth/morojs-adapter.js';
 
 // Export Auth.js middleware and providers
-export { auth, providers } from './core/middleware/built-in/auth';
+export { auth, providers } from './core/middleware/built-in/auth.js';
 
 // Runtime system exports
 export type {
@@ -43,7 +43,7 @@ export type {
   RuntimeAdapter,
   RuntimeConfig,
   RuntimeHttpResponse,
-} from './types/runtime';
+} from './types/runtime.js';
 
 export {
   NodeRuntimeAdapter,
@@ -55,23 +55,27 @@ export {
   createEdgeHandler,
   createLambdaHandler,
   createWorkerHandler,
-} from './core/runtime';
+} from './core/runtime/index.js';
 
 // Runtime-specific types
-export type { LambdaEvent, LambdaContext, LambdaResponse } from './core/runtime/aws-lambda-adapter';
-export type { WorkersEnv, WorkersContext } from './core/runtime/cloudflare-workers-adapter';
+export type {
+  LambdaEvent,
+  LambdaContext,
+  LambdaResponse,
+} from './core/runtime/aws-lambda-adapter.js';
+export type { WorkersEnv, WorkersContext } from './core/runtime/cloudflare-workers-adapter.js';
 
 // Core exports
-export { MoroHttpServer, middleware as httpMiddleware } from './core/http';
-export { builtInMiddleware, simpleMiddleware } from './core/middleware/built-in';
+export {
+  MoroHttpServer,
+  UWebSocketsHttpServer,
+  middleware as httpMiddleware,
+} from './core/http/index.js';
+export { builtInMiddleware, simpleMiddleware } from './core/middleware/built-in/index.js';
 
 // Networking System
-export {
-  WebSocketManager,
-  ServiceRegistry,
-  ServiceInfo,
-  ServiceDiscoveryOptions,
-} from './core/networking';
+export { WebSocketManager, ServiceRegistry } from './core/networking/index.js';
+export type { ServiceInfo, ServiceDiscoveryOptions } from './core/networking/service-discovery.js';
 
 // Utilities and Container System
 export {
@@ -87,10 +91,13 @@ export {
   HookManager,
   HOOK_EVENTS,
   middleware,
-} from './core/utilities';
+  isPackageAvailable,
+  resolveUserPackage,
+  createUserRequire,
+} from './core/utilities/index.js';
 
 // Event System
-export { MoroEventBus } from './core/events';
+export { MoroEventBus } from './core/events/index.js';
 export type {
   EventContext,
   EventPayload,
@@ -100,38 +107,29 @@ export type {
   EventMetrics,
   SystemEvents,
   EventHandler,
-} from './types/events';
+} from './types/events.js';
 
 // Logger System
-export { createFrameworkLogger, logger } from './core/logger';
+export { createFrameworkLogger, logger } from './core/logger/index.js';
 
 // Universal Validation System
-export { validate, body, query, params, combineSchemas } from './core/validation';
-
-// Dynamic Zod export (optional dependency)
-let z: any;
-try {
-  z = require('zod').z;
-} catch {
-  // Zod not available - that's fine!
-  z = undefined;
-}
-export { z };
+export { validate, body, query, params, combineSchemas, z } from './core/validation/index.js';
+
 export type {
   ValidationConfig,
   ValidationResult,
   ValidationErrorDetail,
   ValidatedRequest,
-} from './core/validation';
+} from './core/validation/index.js';
 
-// Universal Validation Interfaces and Adapters
+// 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';
+} from './core/validation/schema-interface.js';
+export { normalizeValidationError } from './core/validation/schema-interface.js';
+export { joi, yup, fn as customValidator, classValidator } from './core/validation/adapters.js';
 
 // Module System
 export {
@@ -139,8 +137,8 @@ export {
   ModuleLoader,
   ModuleDiscovery,
   autoDiscoverModuleDirectories,
-} from './core/modules';
-export type { ModuleDefinition, ModuleRoute, ModuleSocket, ModuleConfig } from './types/module';
+} from './core/modules/index.js';
+export type { ModuleDefinition, ModuleRoute, ModuleSocket, ModuleConfig } from './types/module.js';
 
 // WebSocket Adapter System
 export type {
@@ -151,14 +149,18 @@ export type {
   WebSocketEmitter,
   WebSocketMiddleware,
   WebSocketEventHandler,
-} from './core/networking/websocket-adapter';
+} from './core/networking/websocket-adapter.js';
 
 // Built-in WebSocket Adapters
-export { SocketIOAdapter, WSAdapter } from './core/networking/adapters';
+export {
+  SocketIOAdapter,
+  WSAdapter,
+  UWebSocketsAdapter,
+} from './core/networking/adapters/index.js';
 
 // Intelligent Routing System
-export { createRoute, defineRoute, EXECUTION_PHASES } from './core/routing';
-export { IntelligentRoutingManager, RouteRegistry } from './core/routing/app-integration';
+export { createRoute, defineRoute, EXECUTION_PHASES } from './core/routing/index.js';
+export { IntelligentRoutingManager, RouteRegistry } from './core/routing/app-integration.js';
 export type {
   RouteBuilder,
   RouteSchema,
@@ -169,7 +171,7 @@ export type {
   CacheConfig,
   MiddlewarePhases,
   ExecutionPhase,
-} from './core/routing';
+} from './core/routing/index.js';
 
 // Documentation System
 export {
@@ -177,8 +179,8 @@ export {
   AppDocumentationManager,
   createDocumentationSystem,
   generateDocsFromIntelligentRoutes,
-} from './core/docs';
-export type { DocsConfig } from './core/docs';
+} from './core/docs/index.js';
+export type { DocsConfig } from './core/docs/index.js';
 
 // Configuration utilities
 export {
@@ -193,34 +195,39 @@ export {
   requireEnvVars,
   envVar,
   getConfigValue,
-} from './core/config/utils';
+} from './core/config/utils.js';
 
-export { initializeConfig, getGlobalConfig, isConfigInitialized, resetConfig } from './core/config';
+export {
+  initializeConfig,
+  getGlobalConfig,
+  isConfigInitialized,
+  resetConfig,
+} from './core/config/index.js';
 
 // Export configuration types for TypeScript users
-export type { AppConfig } from './core/config';
+export type { AppConfig } from './core/config/index.js';
 
 // Middleware System
-export { MiddlewareManager } from './core/middleware';
-export type { MiddlewareInterface, MoroMiddleware } from './core/middleware';
+export { MiddlewareManager } from './core/middleware/index.js';
+export type { MiddlewareInterface, MoroMiddleware } from './core/middleware/index.js';
 
 // Types
-export type * from './types/core';
-export type * from './types/http';
-export type * from './types/hooks';
-export type * from './types/cache';
-export type * from './types/cdn';
-export type * from './types/database';
-export type * from './types/logger';
-export type * from './types/session';
-export type * from './types/discovery';
+export type * from './types/core.js';
+export type * from './types/http.js';
+export type * from './types/hooks.js';
+export type * from './types/cache.js';
+export type * from './types/cdn.js';
+export type * from './types/database.js';
+export type * from './types/logger.js';
+export type * from './types/session.js';
+export type * from './types/discovery.js';
 
 // Adapters
-export * from './core/middleware/built-in/adapters';
-export * from './core/database/adapters';
+export * from './core/middleware/built-in/adapters/index.js';
+export * from './core/database/adapters/index.js';
 
 // Re-export commonly used types for convenience
-export type { CacheAdapter, CacheOptions, CacheStrategy } from './types/cache';
-export type { CDNAdapter, CDNOptions } from './types/cdn';
-export type { DatabaseAdapter, DatabaseTransaction, DatabaseConfig } from './types/database';
-export type { CookieOptions } from './types/http';
+export type { CacheAdapter, CacheOptions, CacheStrategy } from './types/cache.js';
+export type { CDNAdapter, CDNOptions } from './types/cdn.js';
+export type { DatabaseAdapter, DatabaseTransaction, DatabaseConfig } from './types/database.js';
+export type { CookieOptions } from './types/http.js';

package/src/moro.ts

@@ -1,26 +1,29 @@
 // Moro Framework - Modern TypeScript API Framework
 // Built for developers who demand performance, elegance, and zero compromises
 // Event-driven • Modular • Enterprise-ready • Developer-first
-import { Moro as MoroCore } from './core/framework';
-import { HttpRequest, HttpResponse, middleware } from './core/http';
-import { ModuleConfig, InternalRouteDefinition } from './types/module';
-import { MoroOptions } from './types/core';
-import { ModuleDefaultsConfig } from './types/config';
-import { MoroEventBus } from './core/events';
-import { createFrameworkLogger, applyLoggingConfiguration } from './core/logger';
-import { Logger } from './types/logger';
-import { MiddlewareManager } from './core/middleware';
-import { IntelligentRoutingManager } from './core/routing/app-integration';
-import { RouteBuilder, RouteSchema, CompiledRoute } from './core/routing';
-import { AppDocumentationManager, DocsConfig } from './core/docs';
+import { Moro as MoroCore } from './core/framework.js';
+import { HttpRequest, HttpResponse, middleware } from './core/http/index.js';
+import { ModuleConfig, InternalRouteDefinition } from './types/module.js';
+import { MoroOptions } from './types/core.js';
+import { ModuleDefaultsConfig } from './types/config.js';
+import { MoroEventBus } from './core/events/index.js';
+import { createFrameworkLogger, applyLoggingConfiguration } from './core/logger/index.js';
+import { Logger } from './types/logger.js';
+import { MiddlewareManager } from './core/middleware/index.js';
+import { IntelligentRoutingManager } from './core/routing/app-integration.js';
+import { RouteBuilder, RouteSchema, CompiledRoute } from './core/routing/index.js';
+import { AppDocumentationManager, DocsConfig } from './core/docs/index.js';
 import { EventEmitter } from 'events';
+import cluster from 'cluster';
+import os from 'os';
+import { normalizeValidationError } from './core/validation/schema-interface.js';
 // Configuration System Integration
-import { initializeConfig, type AppConfig } from './core/config';
+import { initializeConfig, type AppConfig } from './core/config/index.js';
 // Runtime System Integration
-import { RuntimeAdapter, RuntimeType, createRuntimeAdapter } from './core/runtime';
+import { RuntimeAdapter, RuntimeType, createRuntimeAdapter } from './core/runtime/index.js';
 
 export class Moro extends EventEmitter {
-  private coreFramework: MoroCore;
+  private coreFramework!: MoroCore;
   private routes: InternalRouteDefinition[] = [];
   private moduleCounter = 0;
   private loadedModules = new Set<string>();
@@ -31,7 +34,7 @@ export class Moro extends EventEmitter {
   private autoDiscoveryInitialized = false;
   private autoDiscoveryPromise: Promise<void> | null = null;
   // Enterprise event system integration
-  private eventBus: MoroEventBus;
+  private eventBus!: MoroEventBus;
   // Application logger
   private logger!: Logger;
   // Intelligent routing system
@@ -39,12 +42,18 @@ export class Moro extends EventEmitter {
   // Documentation system
   private documentation = new AppDocumentationManager();
   // Configuration system
-  private config: AppConfig;
+  private config!: AppConfig;
   // Runtime system
-  private runtimeAdapter: RuntimeAdapter;
-  private runtimeType: RuntimeType;
+  private runtimeAdapter!: RuntimeAdapter;
+  private runtimeType!: RuntimeType;
   // Middleware system
-  private middlewareManager: MiddlewareManager;
+  private middlewareManager!: MiddlewareManager;
+  // Queued WebSocket registrations (for async adapter detection)
+  private queuedWebSocketRegistrations: Array<{
+    namespace: string;
+    handlers: Record<string, Function>;
+    processed: boolean;
+  }> = [];
 
   constructor(options: MoroOptions = {}) {
     super(); // Call EventEmitter constructor
@@ -88,7 +97,11 @@ export class Moro extends EventEmitter {
     const frameworkOptions: any = {
       ...options,
       logger: this.config.logging,
-      websocket: this.config.websocket.enabled ? options.websocket || {} : false,
+      // Enable websockets if either config has it enabled OR user passed websocket options
+      websocket:
+        this.config.websocket.enabled || options.websocket
+          ? options.websocket || this.config.websocket || {}
+          : false,
       config: this.config,
     };
 
@@ -375,34 +388,45 @@ export class Moro extends EventEmitter {
 
   // WebSocket helper with events
   websocket(namespace: string, handlers: Record<string, Function>) {
+    // Queue the registration to be processed after adapter initialization
+    const registration = { namespace, handlers, processed: false };
+    this.queuedWebSocketRegistrations.push(registration);
+
+    // Try to process immediately if adapter is already ready
     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() } })'
-      );
+    if (adapter && !registration.processed) {
+      // Adapter is ready, process immediately
+      this.processWebSocketRegistration(namespace, handlers, adapter);
+      registration.processed = true;
     }
+    // Otherwise, it will be processed when the server starts
+
+    return this;
+  }
 
+  private processWebSocketRegistration(
+    namespace: string,
+    handlers: Record<string, Function>,
+    adapter: any
+  ) {
     this.emit('websocket:registering', { namespace, handlers });
 
     const ns = adapter.createNamespace(namespace);
 
     Object.entries(handlers).forEach(([event, handler]) => {
-      ns.on('connection', socket => {
+      ns.on('connection', (socket: any) => {
         this.emit('websocket:connection', { namespace, event, socket });
 
-        socket.on(event, (data, callback) => {
+        socket.on(event, (data: any, callback: any) => {
           this.emit('websocket:event', { namespace, event, data });
 
           Promise.resolve(handler(socket, data))
-            .then(result => {
+            .then((result: any) => {
               this.emit('websocket:response', { namespace, event, result });
               if (callback) callback(result);
               else if (result) socket.emit(`${event}:response`, result);
             })
-            .catch(error => {
+            .catch((error: any) => {
               this.emit('websocket:error', { namespace, event, error });
               const errorResponse = { success: false, error: error.message };
               if (callback) callback(errorResponse);
@@ -413,7 +437,40 @@ export class Moro extends EventEmitter {
     });
 
     this.emit('websocket:registered', { namespace, handlers });
-    return this;
+  }
+
+  private async processQueuedWebSocketRegistrations() {
+    // Wait for WebSocket adapter to be ready
+    await this.coreFramework.ensureWebSocketReady();
+
+    const adapter = this.coreFramework.getWebSocketAdapter();
+
+    // Check if any unprocessed registrations exist
+    const unprocessedRegistrations = this.queuedWebSocketRegistrations.filter(r => !r.processed);
+
+    if (!adapter && unprocessedRegistrations.length > 0) {
+      throw new Error(
+        'WebSocket features require a WebSocket adapter.\n\n' +
+          'Option 1: Install socket.io (auto-detected):\n' +
+          '  npm install socket.io\n' +
+          '  const app = new Moro({ websocket: {} });\n\n' +
+          'Option 2: Configure a specific adapter:\n' +
+          "  import { SocketIOAdapter } from '@morojs/moro';\n" +
+          '  const app = new Moro({ websocket: { adapter: new SocketIOAdapter() } });\n\n' +
+          'Option 3: Enable in config file (moro.config.js):\n' +
+          '  export default { websocket: { enabled: true } };'
+      );
+    }
+
+    if (adapter) {
+      // Process all unprocessed registrations
+      for (const registration of this.queuedWebSocketRegistrations) {
+        if (!registration.processed) {
+          this.processWebSocketRegistration(registration.namespace, registration.handlers, adapter);
+          registration.processed = true;
+        }
+      }
+    }
   }
 
   // Start server with events (Node.js only)
@@ -469,9 +526,21 @@ export class Moro extends EventEmitter {
     }
 
     // Check if clustering is enabled for massive performance gains
+    // NOTE: uWebSockets.js does NOT support Node.js clustering - it's single-threaded only
+    const usingUWebSockets = this.config.server?.useUWebSockets || false;
+
     if (this.config.performance?.clustering?.enabled) {
-      this.startWithClustering(port, host as string, callback);
-      return;
+      if (usingUWebSockets) {
+        this.logger.warn(
+          'Clustering is not supported with uWebSockets.js - running in single-threaded mode. ' +
+            'uWebSockets is so fast that single-threaded performance often exceeds multi-threaded Node.js!',
+          'Cluster'
+        );
+        // Continue without clustering
+      } else {
+        this.startWithClustering(port, host as string, callback);
+        return;
+      }
     }
     this.eventBus.emit('server:starting', { port, runtime: this.runtimeType });
 
@@ -529,16 +598,23 @@ export class Moro extends EventEmitter {
       }
     };
 
-    // Ensure auto-discovery is complete before starting server
-    this.ensureAutoDiscoveryComplete()
+    // Ensure auto-discovery and WebSocket setup is complete before starting server
+    Promise.all([this.ensureAutoDiscoveryComplete(), this.processQueuedWebSocketRegistrations()])
       .then(() => {
         startServer();
       })
       .catch(error => {
-        this.logger.error('Auto-discovery initialization failed during server start', 'Framework', {
+        this.logger.error('Initialization failed during server start', 'Framework', {
           error: error instanceof Error ? error.message : String(error),
         });
-        // Start server anyway - auto-discovery failure shouldn't prevent startup
+        // For auto-discovery failures, start server anyway
+        // For WebSocket failures with queued registrations, error will propagate
+        if (
+          error instanceof Error &&
+          error.message.includes('WebSocket features require a WebSocket adapter')
+        ) {
+          throw error;
+        }
         startServer();
       });
   }
@@ -901,7 +977,6 @@ export class Moro extends EventEmitter {
               req.body = validated;
             } catch (error: any) {
               // Handle universal validation errors
-              const { normalizeValidationError } = require('./core/validation/schema-interface');
               const normalizedError = normalizeValidationError(error);
               res.status(400).json({
                 success: false,
@@ -1016,7 +1091,7 @@ export class Moro extends EventEmitter {
 
   // Enhanced auto-discovery initialization
   private async initializeAutoDiscovery(options: MoroOptions): Promise<void> {
-    const { ModuleDiscovery } = await import('./core/modules/auto-discovery');
+    const { ModuleDiscovery } = await import('./core/modules/auto-discovery.js');
 
     // Merge auto-discovery configuration
     const autoDiscoveryConfig = this.mergeAutoDiscoveryConfig(options);
@@ -1251,9 +1326,6 @@ export class Moro extends EventEmitter {
   private clusterWorkers = new Map<number, any>();
 
   private startWithClustering(port: number, host?: string, callback?: () => void): void {
-    const cluster = require('cluster');
-    const os = require('os');
-
     // Worker count calculation - respect user choice
     let workerCount = this.config.performance?.clustering?.workers || os.cpus().length;
 
@@ -1374,9 +1446,8 @@ export class Moro extends EventEmitter {
       }
 
       // Research-based memory optimization for workers
-      const os = require('os');
       const totalMemoryGB = os.totalmem() / (1024 * 1024 * 1024);
-      const workerCount = Object.keys(require('cluster').workers || {}).length || 1;
+      const workerCount = Object.keys(cluster.workers || {}).length || 1;
 
       // Conservative memory allocation
       const heapSizePerWorkerMB = Math.min(
@@ -1477,11 +1548,33 @@ export class Moro extends EventEmitter {
         });
       };
 
-      if (host) {
-        this.coreFramework.listen(port, host, workerCallback);
-      } else {
-        this.coreFramework.listen(port, workerCallback);
-      }
+      // Ensure WebSocket setup is complete before starting worker
+      this.processQueuedWebSocketRegistrations()
+        .then(() => {
+          if (host) {
+            this.coreFramework.listen(port, host, workerCallback);
+          } else {
+            this.coreFramework.listen(port, workerCallback);
+          }
+        })
+        .catch(error => {
+          this.logger.error('WebSocket initialization failed in worker', 'Worker', {
+            error: error instanceof Error ? error.message : String(error),
+          });
+          // For WebSocket failures with queued registrations, error will propagate
+          if (
+            error instanceof Error &&
+            error.message.includes('WebSocket features require a WebSocket adapter')
+          ) {
+            throw error;
+          }
+          // Start anyway for other errors
+          if (host) {
+            this.coreFramework.listen(port, host, workerCallback);
+          } else {
+            this.coreFramework.listen(port, workerCallback);
+          }
+        });
     }
   }
 

package/src/types/config.ts

@@ -12,6 +12,12 @@ export interface ServerConfig {
   errorBoundary: {
     enabled: boolean;
   };
+  useUWebSockets?: boolean; // Enable uWebSockets for both HTTP and WebSocket
+  ssl?: {
+    key_file_name?: string;
+    cert_file_name?: string;
+    passphrase?: string;
+  };
 }
 
 export interface ServiceDiscoveryConfig {
@@ -187,7 +193,7 @@ export interface PerformanceConfig {
 
 export interface WebSocketConfig {
   enabled: boolean;
-  adapter?: string | 'socket.io' | 'ws';
+  adapter?: string | 'socket.io' | 'ws' | 'uws';
   compression?: boolean;
   customIdGenerator?: () => string;
   options?: {
@@ -197,6 +203,12 @@ export interface WebSocketConfig {
     };
     path?: string;
     maxPayloadLength?: number;
+    idleTimeout?: number;
+    ssl?: {
+      key_file_name?: string;
+      cert_file_name?: string;
+      passphrase?: string;
+    };
   };
 }
 

package/src/types/core.ts

@@ -1,7 +1,7 @@
 // Core Framework Types
-import { RuntimeConfig } from './runtime';
-import { LogLevel, LoggerOptions } from './logger';
-import { AppConfig } from './config';
+import { RuntimeConfig } from './runtime.js';
+import { LogLevel, LoggerOptions } from './logger.js';
+import { AppConfig } from './config.js';
 
 export interface MoroOptions {
   autoDiscover?:

package/src/types/hooks.ts

@@ -1,5 +1,5 @@
 // Hooks and Middleware Types
-import { HttpRequest, HttpResponse } from './http';
+import { HttpRequest, HttpResponse } from '../core/http/index.js';
 
 export type HookFunction = (...args: any[]) => Promise<any> | any;
 

package/src/types/runtime.ts

@@ -1,5 +1,5 @@
 // Runtime abstraction types for multi-environment support
-import { HttpRequest, HttpResponse } from './http';
+import { HttpRequest, HttpResponse } from '../core/http/index.js';
 
 export type RuntimeType = 'node' | 'vercel-edge' | 'aws-lambda' | 'cloudflare-workers';
 

package/tsconfig.json

@@ -2,7 +2,8 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "commonjs",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "lib": ["ES2022"],
     "outDir": "./dist",
     "rootDir": "./src",
@@ -14,7 +15,8 @@
     "emitDecoratorMetadata": true,
     "resolveJsonModule": true,
     "declaration": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "isolatedModules": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]