@morojs/moro 1.5.17 → 1.6.1

package/src/core/http/router.ts

@@ -12,14 +12,6 @@ export class Router {
   private routes: RouteDefinition[] = [];
   private logger = createFrameworkLogger('Router');
 
-  // Performance optimizations - O(1) static route lookup
-  private staticRoutes = new Map<string, RouteDefinition>(); // "GET:/api/users" -> route
-  private dynamicRoutes: RouteDefinition[] = []; // Routes with parameters
-
-  // Object pooling for parameters to reduce GC pressure
-  private paramObjectPool: Record<string, string>[] = [];
-  private readonly maxPoolSize = 50;
-
   get(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
     this.addRoute('GET', path, handlers);
   }
@@ -45,37 +37,14 @@ export class Router {
     const handler = handlers.pop() as HttpHandler;
     const middleware = handlers as Middleware[];
 
-    const route: RouteDefinition = {
+    this.routes.push({
       method,
       path,
       pattern,
       paramNames,
       handler,
       middleware,
-    };
-
-    // Add to routes array (maintain compatibility)
-    this.routes.push(route);
-
-    // Performance optimization: separate static and dynamic routes
-    const isStatic = !path.includes(':') && !path.includes('*');
-    if (isStatic && middleware.length === 0) {
-      // Static route with no middleware - use O(1) lookup
-      const routeKey = `${method}:${path}`;
-      this.staticRoutes.set(routeKey, route);
-      this.logger.debug(`Added static route: ${routeKey}`, 'FastRoute');
-    } else {
-      // Dynamic route or has middleware - needs regex matching
-      this.dynamicRoutes.push(route);
-      this.logger.debug(`Added dynamic route: ${method} ${path}`, 'DynamicRoute');
-    }
-
-    // Initialize object pool on first route
-    if (this.paramObjectPool.length === 0) {
-      for (let i = 0; i < this.maxPoolSize; i++) {
-        this.paramObjectPool.push({});
-      }
-    }
+    });
   }
 
   private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
@@ -108,30 +77,10 @@ export class Router {
       'Processing'
     );
 
-    // PERFORMANCE OPTIMIZATION: Fast path - O(1) static route lookup first
-    const routeKey = `${req.method}:${path}`;
-    const staticRoute = this.staticRoutes.get(routeKey);
-
-    if (staticRoute) {
-      this.logger.debug(`Fast route match: ${routeKey}`, 'FastRoute');
-
-      // Static route with no middleware - execute handler directly
-      req.params = {}; // No params for static routes
-      const result = await staticRoute.handler(req, res);
-
-      // If handler returns data and response hasn't been sent, send it
-      if (result !== undefined && result !== null && !res.headersSent) {
-        res.json(result);
-      }
-
-      return true;
-    }
-
-    // Fallback: Dynamic route matching (with middleware support)
-    const route = this.dynamicRoutes.find(r => r.method === req.method && r.pattern.test(path));
+    const route = this.routes.find(r => r.method === req.method && r.pattern.test(path));
 
     this.logger.debug(
-      `Found dynamic route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
+      `Found route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
       'RouteMatch'
     );
 
@@ -139,92 +88,54 @@ export class Router {
       return false; // Route not found
     }
 
-    // Extract path parameters using object pooling
+    // Extract path parameters
     const matches = path.match(route.pattern);
     if (matches) {
-      req.params = this.acquireParamObject();
+      req.params = {};
       route.paramNames.forEach((name, index) => {
         req.params[name] = matches[index + 1];
       });
     }
 
-    try {
-      // Execute middleware
-      for (const mw of route.middleware) {
-        await new Promise<void>((resolve, reject) => {
-          let nextCalled = false;
-
-          const next = () => {
-            if (nextCalled) return;
-            nextCalled = true;
-            resolve();
-          };
-
-          try {
-            const result = mw(req, res, next);
-
-            if (result instanceof Promise) {
-              result
-                .then(() => {
-                  if (!nextCalled) next();
-                })
-                .catch(reject);
-            }
-          } catch (error) {
-            reject(error);
+    // Execute middleware
+    for (const mw of route.middleware) {
+      await new Promise<void>((resolve, reject) => {
+        let nextCalled = false;
+
+        const next = () => {
+          if (nextCalled) return;
+          nextCalled = true;
+          resolve();
+        };
+
+        try {
+          const result = mw(req, res, next);
+
+          if (result instanceof Promise) {
+            result
+              .then(() => {
+                if (!nextCalled) next();
+              })
+              .catch(reject);
           }
-        });
-
-        if (res.headersSent) break; // Early exit if response sent
-      }
-
-      // Execute handler
-      const result = await route.handler(req, res);
-
-      // If handler returns data and response hasn't been sent, send it
-      if (result !== undefined && result !== null && !res.headersSent) {
-        res.json(result);
-      }
-
-      return true;
-    } finally {
-      // Release parameter object back to pool
-      if (req.params && matches) {
-        this.releaseParamObject(req.params);
-      }
+        } catch (error) {
+          reject(error);
+        }
+      });
     }
-  }
 
-  getRoutes(): RouteDefinition[] {
-    return [...this.routes];
-  }
+    // Execute handler
+    const result = await route.handler(req, res);
 
-  // Object pooling methods for performance optimization
-  private acquireParamObject(): Record<string, string> {
-    const obj = this.paramObjectPool.pop();
-    if (obj) {
-      // Clear the object
-      for (const key in obj) {
-        delete obj[key];
-      }
-      return obj;
+    // If handler returns data and response hasn't been sent, send it
+    if (result !== undefined && result !== null && !res.headersSent) {
+      res.json(result);
     }
-    return {};
-  }
 
-  private releaseParamObject(obj: Record<string, string>): void {
-    if (this.paramObjectPool.length < this.maxPoolSize) {
-      this.paramObjectPool.push(obj);
-    }
+    return true;
   }
 
-  // Performance statistics for monitoring
-  getPerformanceStats() {
-    return {
-      totalRoutes: this.routes.length,
-      staticRoutes: this.staticRoutes.size,
-      dynamicRoutes: this.dynamicRoutes.length,
-      paramObjectPoolSize: this.paramObjectPool.length,
-    };
+  getRoutes(): RouteDefinition[] {
+    return [...this.routes];
   }
 }

package/src/core/logger/filters.ts

@@ -22,24 +22,16 @@ export const contextFilter = (allowedContexts: string[]): LogFilter => ({
 // Rate limiting filter
 export const rateLimitFilter = (maxPerSecond: number): LogFilter => {
   const timestamps: number[] = [];
-  let lastCleanup = 0;
 
   return {
     name: 'rate-limit',
     filter: (entry: LogEntry) => {
       const now = Date.now();
+      const oneSecondAgo = now - 1000;
 
-      // Batch cleanup for better performance and thread safety
-      if (now - lastCleanup > 1000) {
-        const cutoff = now - 1000;
-        let keepIndex = 0;
-        for (let i = 0; i < timestamps.length; i++) {
-          if (timestamps[i] >= cutoff) {
-            timestamps[keepIndex++] = timestamps[i];
-          }
-        }
-        timestamps.length = keepIndex;
-        lastCleanup = now;
+      // Remove old timestamps
+      while (timestamps.length > 0 && timestamps[0] < oneSecondAgo) {
+        timestamps.shift();
       }
 
       // Check rate limit

package/src/core/logger/index.ts

@@ -5,7 +5,6 @@ export {
   createFrameworkLogger,
   configureGlobalLogger,
   applyLoggingConfiguration,
-  destroyGlobalLogger,
 } from './logger';
 export * from './filters';