@morojs/moro 1.5.17 → 1.6.0

package/src/core/docs/openapi-generator.ts

@@ -1,10 +1,10 @@
 // OpenAPI Specification Generator for Moro Framework
 // Extracts route information from intelligent routing and generates OpenAPI 3.0 specs
 
-import { CompiledRoute, RouteSchema } from '../routing';
-import { OpenAPISchema } from './zod-to-openapi';
-import { schemaToOpenAPI, generateExampleFromValidationSchema } from './schema-to-openapi';
-import { createFrameworkLogger } from '../logger';
+import { CompiledRoute, RouteSchema } from '../routing/index.js';
+import { OpenAPISchema } from './zod-to-openapi.js';
+import { schemaToOpenAPI, generateExampleFromValidationSchema } from './schema-to-openapi.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('OpenAPIGenerator');
 

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

@@ -1,9 +1,9 @@
 // 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';
+import { ValidationSchema } from '../validation/schema-interface.js';
+import { OpenAPISchema, zodToOpenAPI, generateExampleFromSchema } from './zod-to-openapi.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('SchemaToOpenAPI');
 
@@ -32,8 +32,6 @@ export function schemaToOpenAPI(
   // 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));
@@ -59,7 +57,6 @@ export function generateExampleFromValidationSchema(schema: ValidationSchema): a
   // 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));

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

@@ -1,8 +1,8 @@
 // Simple Documentation Generator - Fallback for when Swagger UI has issues
 // Generates clean, readable API documentation from routes
 
-import { CompiledRoute, RouteSchema } from '../routing';
-import { createFrameworkLogger } from '../logger';
+import { CompiledRoute, RouteSchema } from '../routing/index.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('SimpleDocs');
 

package/src/core/docs/swagger-ui.ts

@@ -3,9 +3,10 @@
 
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { HttpRequest, HttpResponse } from '../http';
-import { OpenAPISpec } from './openapi-generator';
-import { createFrameworkLogger } from '../logger';
+import { createUserRequire } from '../utilities/package-utils.js';
+import { HttpRequest, HttpResponse } from '../http/index.js';
+import { OpenAPISpec } from './openapi-generator.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('SwaggerUI');
 
@@ -44,7 +45,9 @@ export class SwaggerUIMiddleware {
     };
 
     try {
-      // Find swagger-ui-dist assets
+      // Find swagger-ui-dist assets using ESM-compatible resolution
+      // Create a require function from the user's working directory to find their installed packages
+      const require = createUserRequire();
       this.swaggerUIAssetPath = require
         .resolve('swagger-ui-dist/package.json')
         .replace('/package.json', '');
@@ -119,37 +122,37 @@ export class SwaggerUIMiddleware {
     <h3>Failed to Load Swagger UI</h3>
     <div id="error-details"></div>
   </div>
-  
+
   <script src="${basePath}/swagger-ui-bundle.js" charset="UTF-8"></script>
   <script src="${basePath}/swagger-ui-standalone-preset.js" charset="UTF-8"></script>
   <script>
     console.log('Starting Swagger UI initialization...');
-    
+
     function showError(message, details) {
       console.error('Swagger UI Error:', message, details);
       document.getElementById('loading-message').style.display = 'none';
       document.getElementById('error-display').style.display = 'block';
-      document.getElementById('error-details').innerHTML = 
+      document.getElementById('error-details').innerHTML =
         '<p><strong>Error:</strong> ' + message + '</p>' +
         (details ? '<pre>' + JSON.stringify(details, null, 2) + '</pre>' : '');
     }
-    
+
     function initializeSwaggerUI() {
       console.log('Initializing Swagger UI...');
-      
+
       if (typeof SwaggerUIBundle === 'undefined') {
         showError('SwaggerUIBundle not loaded', { SwaggerUIBundle: typeof SwaggerUIBundle });
         return;
       }
-      
+
       if (typeof SwaggerUIStandalonePreset === 'undefined') {
         showError('SwaggerUIStandalonePreset not loaded', { SwaggerUIStandalonePreset: typeof SwaggerUIStandalonePreset });
         return;
       }
-      
+
       try {
         console.log('Creating SwaggerUIBundle...');
-        
+
         const ui = SwaggerUIBundle({
           url: '${basePath}/openapi.json',
           dom_id: '#swagger-ui',
@@ -173,10 +176,10 @@ export class SwaggerUIMiddleware {
             showError('Swagger UI initialization failed', error);
           }
         });
-        
+
         window.ui = ui;
         console.log('SwaggerUIBundle created successfully');
-        
+
         // Hide loading message after timeout if onComplete doesn't fire
         setTimeout(function() {
           var loadingEl = document.getElementById('loading-message');
@@ -185,7 +188,7 @@ export class SwaggerUIMiddleware {
             loadingEl.style.display = 'none';
           }
         }, 5000);
-        
+
       } catch (error) {
         console.error('Error creating SwaggerUIBundle:', error);
         showError('Failed to create SwaggerUIBundle', {
@@ -194,7 +197,7 @@ export class SwaggerUIMiddleware {
         });
       }
     }
-    
+
     // Initialize when DOM is ready and scripts are loaded
     if (document.readyState === 'loading') {
       document.addEventListener('DOMContentLoaded', function() {

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

@@ -1,41 +1,39 @@
 // Zod to OpenAPI Schema Converter
 // Transforms Zod schemas into OpenAPI 3.0 schema definitions
 
-import { createFrameworkLogger } from '../logger';
+import { createFrameworkLogger } from '../logger/index.js';
+import { createUserRequire, isPackageAvailable } from '../utilities/package-utils.js';
+
+const logger = createFrameworkLogger('ZodToOpenAPI');
 
 // 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!
-}
+let zodModule: any = null;
+let zodLoadAttempted = false;
 
-const logger = createFrameworkLogger('ZodToOpenAPI');
+// Lazy synchronous initialization for Zod
+function loadZodSync() {
+  if (zodLoadAttempted) {
+    return zodModule;
+  }
+
+  zodLoadAttempted = true;
+
+  try {
+    if (!isPackageAvailable('zod')) {
+      zodModule = null;
+      return zodModule;
+    }
+
+    // Use synchronous require for immediate availability
+    const userRequire = createUserRequire();
+    zodModule = userRequire('zod');
+  } catch {
+    // Zod not available - that's fine!
+    zodModule = null;
+  }
+
+  return zodModule;
+}
 
 // OpenAPI schema types
 export interface OpenAPISchema {
@@ -72,7 +70,8 @@ export interface ConversionOptions {
 // Main conversion function
 export function zodToOpenAPI(schema: any, options: ConversionOptions = {}): OpenAPISchema {
   // Check if Zod is available
-  if (!ZodSchema) {
+  const zod = loadZodSync();
+  if (!zod) {
     throw new Error('Zod is not installed. Please install zod to use zodToOpenAPI function.');
   }
 
@@ -420,7 +419,8 @@ function hasDefault(type: any): boolean {
 // Generate example data from Zod schema
 export function generateExampleFromSchema(schema: any): any {
   // Check if Zod is available
-  if (!ZodSchema) {
+  const zod = loadZodSync();
+  if (!zod) {
     throw new Error(
       'Zod is not installed. Please install zod to use generateExampleFromSchema function.'
     );

package/src/core/events/event-bus.ts

@@ -8,8 +8,8 @@ import {
   GlobalEventBus,
   EventMetrics,
   EventHandler,
-} from '../../types/events';
-import { createFrameworkLogger } from '../logger';
+} from '../../types/events.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 export class MoroEventBus implements GlobalEventBus {
   private emitter = new EventEmitter();

package/src/core/events/index.ts

@@ -1,5 +1,5 @@
 // Event System - Centralized Exports
-export { MoroEventBus } from './event-bus';
+export { MoroEventBus } from './event-bus.js';
 export type {
   EventContext,
   EventPayload,
@@ -9,4 +9,4 @@ export type {
   EventMetrics,
   SystemEvents,
   EventHandler,
-} from '../../types/events';
+} from '../../types/events.js';

package/src/core/framework.ts

@@ -5,18 +5,20 @@ import {
   createServer as createHttp2Server,
 } from 'http2';
 import { EventEmitter } from 'events';
-import { MoroHttpServer, HttpRequest, HttpResponse, middleware } from './http';
-import { Router } from './http';
-import { Container } from './utilities';
-import { ModuleLoader } from './modules';
-import { WebSocketManager } from './networking';
-import { CircuitBreaker } from './utilities';
-import { MoroEventBus } from './events';
-import { createFrameworkLogger, logger as globalLogger } from './logger';
-import { ModuleConfig, InternalRouteDefinition } from '../types/module';
-import { LogLevel, LoggerOptions } from '../types/logger';
-import { MoroOptions as CoreMoroOptions } from '../types/core';
-import { WebSocketAdapter, WebSocketAdapterOptions } from './networking/websocket-adapter';
+import { MoroHttpServer, HttpRequest, HttpResponse, middleware } from './http/index.js';
+import { UWebSocketsHttpServer } from './http/uws-http-server.js';
+import { Router } from './http/router.js';
+import { Container } from './utilities/container.js';
+import { ModuleLoader } from './modules/index.js';
+import { WebSocketManager } from './networking/websocket-manager.js';
+import { CircuitBreaker } from './utilities/circuit-breaker.js';
+import { isPackageAvailable } from './utilities/package-utils.js';
+import { MoroEventBus } from './events/index.js';
+import { createFrameworkLogger, logger as globalLogger } from './logger/index.js';
+import { ModuleConfig, InternalRouteDefinition } from '../types/module.js';
+import { LogLevel, LoggerOptions } from '../types/logger.js';
+import { MoroOptions as CoreMoroOptions } from '../types/core.js';
+import { WebSocketAdapter, WebSocketAdapterOptions } from './networking/websocket-adapter.js';
 
 // Extended MoroOptions that includes both core options and framework-specific options
 export interface MoroOptions extends CoreMoroOptions {
@@ -39,8 +41,8 @@ export interface MoroOptions extends CoreMoroOptions {
 }
 
 export class Moro extends EventEmitter {
-  private httpServer: MoroHttpServer;
-  private server: Server | any; // HTTP/2 server type
+  private httpServer: MoroHttpServer | UWebSocketsHttpServer;
+  private server: Server | any; // HTTP/2 server type or uWebSockets app
   private websocketAdapter?: WebSocketAdapter;
   private container: Container;
   private moduleLoader: ModuleLoader;
@@ -53,6 +55,9 @@ export class Moro extends EventEmitter {
   private logger: any;
   private options: MoroOptions;
   private config: any;
+  private usingUWebSockets = false;
+  // WebSocket initialization promise to handle async adapter detection
+  private websocketSetupPromise: Promise<void> | null = null;
 
   constructor(options: MoroOptions = {}) {
     super();
@@ -77,10 +82,33 @@ export class Moro extends EventEmitter {
     // Initialize framework logger after global configuration
     this.logger = createFrameworkLogger('Core');
 
-    this.httpServer = new MoroHttpServer();
+    // Check if uWebSockets should be used for HTTP and WebSocket
+    const useUWebSockets = this.config.server?.useUWebSockets || false;
+
+    if (useUWebSockets) {
+      try {
+        // Try to use uWebSockets for ultra-high performance HTTP and WebSocket
+        const sslOptions = this.config.server?.ssl || options.https;
+        this.httpServer = new UWebSocketsHttpServer({ ssl: sslOptions });
+        this.server = (this.httpServer as UWebSocketsHttpServer).getApp();
+        this.usingUWebSockets = true;
+        this.logger.info('uWebSockets HTTP+WebSocket server created', 'ServerInit');
+      } catch (error) {
+        // Fallback to standard HTTP/1.1 if uWebSockets fails to load
+        this.logger.warn(
+          'uWebSockets failed to initialize, falling back to Node.js http.Server. ' +
+            'Error: ' +
+            (error instanceof Error ? error.message : String(error)),
+          'ServerInit'
+        );
+        this.usingUWebSockets = false;
+        this.httpServer = new MoroHttpServer();
+        this.server = (this.httpServer as MoroHttpServer).getServer();
+      }
+    } else if (options.http2) {
+      // Use HTTP/2
+      this.httpServer = new MoroHttpServer();
 
-    // Create HTTP/2 or HTTP/1.1 server based on options
-    if (options.http2) {
       if (options.https) {
         this.server = createHttp2SecureServer(options.https);
       } else {
@@ -95,12 +123,14 @@ export class Moro extends EventEmitter {
         req.url = headers[':path'];
         req.method = headers[':method'];
         req.headers = headers;
-        this.httpServer['handleRequest'](req, res);
+        (this.httpServer as MoroHttpServer)['handleRequest'](req, res);
       });
 
       this.logger.info('HTTP/2 server created', 'ServerInit');
     } else {
-      this.server = this.httpServer.getServer();
+      // Use standard HTTP/1.1
+      this.httpServer = new MoroHttpServer();
+      this.server = (this.httpServer as MoroHttpServer).getServer();
     }
 
     this.container = new Container();
@@ -111,7 +141,8 @@ export class Moro extends EventEmitter {
       this.config.websocket.enabled ||
       (options.websocket && typeof options.websocket === 'object')
     ) {
-      this.setupWebSockets(options.websocket || {});
+      // Store the promise so we can await it before using websockets
+      this.websocketSetupPromise = this.setupWebSockets(options.websocket || {});
     }
 
     // Initialize enterprise event bus
@@ -184,29 +215,47 @@ export class Moro extends EventEmitter {
    */
   private async setupWebSockets(wsConfig: any): Promise<void> {
     try {
-      // Use provided adapter or try to auto-detect
-      if (wsConfig.adapter) {
-        this.websocketAdapter = wsConfig.adapter;
+      // If using uWebSockets HTTP server, automatically use uWebSockets for WebSocket too
+      if (this.usingUWebSockets) {
+        const { UWebSocketsAdapter } = await import('./networking/adapters/index.js');
+        this.websocketAdapter = new UWebSocketsAdapter();
+
+        // For uWebSockets, we need to integrate with the existing app
+        const uwsHttpServer = this.httpServer as UWebSocketsHttpServer;
+        await this.websocketAdapter.initialize(uwsHttpServer.getApp(), wsConfig.options);
+
+        this.logger.info(
+          'uWebSockets adapter initialized (integrated with HTTP server)',
+          'WebSocketSetup'
+        );
       } else {
-        this.websocketAdapter = (await this.detectWebSocketAdapter()) || undefined;
+        // 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.logger.info(
+            `WebSocket adapter initialized: ${this.websocketAdapter.getAdapterName()}`,
+            'WebSocketSetup'
+          );
+        }
       }
 
+      // Configure adapter features (if adapter was created)
       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(
@@ -219,26 +268,72 @@ export class Moro extends EventEmitter {
 
   /**
    * Auto-detect available WebSocket adapter
+   * Tests if the library is actually installed by checking require.resolve
    */
   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
+    // Check if adapter is specified in config
+    if (this.config.websocket?.adapter) {
+      const adapterType = this.config.websocket.adapter;
+
+      if (adapterType === 'uws' && isPackageAvailable('uWebSockets.js')) {
+        try {
+          const { UWebSocketsAdapter } = await import('./networking/adapters/index.js');
+          return new UWebSocketsAdapter();
+        } catch {
+          this.logger.warn('uWebSockets.js specified but failed to load', 'AdapterDetection');
+        }
+      } else if (adapterType === 'socket.io' && isPackageAvailable('socket.io')) {
+        try {
+          const { SocketIOAdapter } = await import('./networking/adapters/index.js');
+          return new SocketIOAdapter();
+        } catch {
+          this.logger.warn('socket.io specified but failed to load', 'AdapterDetection');
+        }
+      } else if (adapterType === 'ws' && isPackageAvailable('ws')) {
+        try {
+          const { WSAdapter } = await import('./networking/adapters/index.js');
+          return new WSAdapter();
+        } catch {
+          this.logger.warn('ws specified but failed to load', 'AdapterDetection');
+        }
+      }
     }
 
-    // Try native ws library
-    try {
-      const { WSAdapter } = await import('./networking/adapters');
-      return new WSAdapter();
-    } catch {
-      // ws not available
+    // Auto-detect: Try uWebSockets.js first (highest performance)
+    if (isPackageAvailable('uWebSockets.js')) {
+      try {
+        const { UWebSocketsAdapter } = await import('./networking/adapters/index.js');
+        this.logger.debug('uWebSockets.js detected and loaded', 'AdapterDetection');
+        return new UWebSocketsAdapter();
+      } catch {
+        // Failed to load adapter
+      }
+    }
+
+    // Try socket.io second
+    if (isPackageAvailable('socket.io')) {
+      try {
+        const { SocketIOAdapter } = await import('./networking/adapters/index.js');
+        this.logger.debug('socket.io detected and loaded', 'AdapterDetection');
+        return new SocketIOAdapter();
+      } catch {
+        // Failed to load adapter
+      }
+    }
+
+    // Try native ws library last
+    if (isPackageAvailable('ws')) {
+      try {
+        const { WSAdapter } = await import('./networking/adapters/index.js');
+        this.logger.debug('ws detected and loaded', 'AdapterDetection');
+        return new WSAdapter();
+      } catch {
+        // Failed to load adapter
+      }
     }
 
     this.logger.warn(
-      'No WebSocket adapter found. Install socket.io or ws for WebSocket support',
+      'No WebSocket adapter found. Install uWebSockets.js, socket.io, or ws for WebSocket support',
       'AdapterDetection'
     );
     return null;
@@ -317,6 +412,15 @@ export class Moro extends EventEmitter {
     return this.websocketAdapter;
   }
 
+  /**
+   * Ensure WebSocket setup is complete (for async adapter detection)
+   */
+  async ensureWebSocketReady(): Promise<void> {
+    if (this.websocketSetupPromise) {
+      await this.websocketSetupPromise;
+    }
+  }
+
   /**
    * Get the WebSocket manager
    */

package/src/core/http/http-server.ts

@@ -1,9 +1,17 @@
 // src/core/http-server.ts
 import { IncomingMessage, ServerResponse, createServer, Server } from 'http';
 import * as zlib from 'zlib';
+import { createReadStream } from 'fs';
+import * as crypto from 'crypto';
 import { promisify } from 'util';
-import { createFrameworkLogger } from '../logger';
-import { HttpRequest, HttpResponse, HttpHandler, Middleware, RouteEntry } from '../../types/http';
+import { createFrameworkLogger } from '../logger/index.js';
+import {
+  HttpRequest,
+  HttpResponse,
+  HttpHandler,
+  Middleware,
+  RouteEntry,
+} from '../../types/http.js';
 
 const gzip = promisify(zlib.gzip);
 const deflate = promisify(zlib.deflate);
@@ -1133,7 +1141,6 @@ export const middleware = {
   },
 
   compression: (options: { threshold?: number; level?: number } = {}): Middleware => {
-    const zlib = require('zlib');
     const threshold = options.threshold || 1024;
     const level = options.level || 6;
 
@@ -1719,7 +1726,7 @@ export const middleware = {
             res.setHeader('Content-Length', chunkSize);
 
             // Stream the range
-            const stream = require('fs').createReadStream(filePath, {
+            const stream = createReadStream(filePath, {
               start,
               end,
             });
@@ -1737,12 +1744,12 @@ export const middleware = {
               res.write(`\r\n--${boundary}\r\n`);
               res.write(`Content-Range: bytes ${start}-${end}/${fileSize}\r\n\r\n`);
 
-              const stream = require('fs').createReadStream(filePath, {
+              const stream = createReadStream(filePath, {
                 start,
                 end,
               });
-              await new Promise(resolve => {
-                stream.on('end', resolve);
+              await new Promise<void>(resolve => {
+                stream.on('end', () => resolve());
                 stream.pipe(res, { end: false });
               });
             }
@@ -1776,7 +1783,6 @@ export const middleware = {
     const ignoreMethods = options.ignoreMethods || ['GET', 'HEAD', 'OPTIONS'];
 
     const generateToken = () => {
-      const crypto = require('crypto');
       return crypto.randomBytes(tokenLength).toString('hex');
     };
 
@@ -1865,7 +1871,6 @@ export const middleware = {
       // Generate nonce if requested
       let nonce: string | undefined;
       if (options.nonce) {
-        const crypto = require('crypto');
         nonce = crypto.randomBytes(16).toString('base64');
         (req as any).cspNonce = nonce;
       }

package/src/core/http/index.ts

@@ -1,6 +1,7 @@
 // HTTP System - Centralized Exports
-export { MoroHttpServer, middleware } from './http-server';
-export { Router } from './router';
+export { MoroHttpServer, middleware } from './http-server.js';
+export { UWebSocketsHttpServer } from './uws-http-server.js';
+export { Router } from './router.js';
 
 // Type exports
-export type { HttpRequest, HttpResponse, HttpHandler, Middleware } from '../../types/http';
+export type { HttpRequest, HttpResponse, HttpHandler, Middleware } from '../../types/http.js';

package/src/core/http/router.ts

@@ -5,8 +5,8 @@ import {
   HttpHandler,
   Middleware,
   RouteDefinition,
-} from '../../types/http';
-import { createFrameworkLogger } from '../logger';
+} from '../../types/http.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 export class Router {
   private routes: RouteDefinition[] = [];