@morojs/moro 1.6.2 → 1.6.3

package/src/core/routing/unified-router.ts

@@ -1,870 +0,0 @@
-// Unified Router - Consolidates Intelligent Router and Core Router
-// Combines best features from both systems with zero breaking changes
-
-import { PathMatcher, CompiledPath } from './path-matcher.js';
-import { ObjectPoolManager } from '../pooling/object-pool-manager.js';
-import { createFrameworkLogger } from '../logger/index.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { ValidationSchema } from '../validation/schema-interface.js';
-
-const logger = createFrameworkLogger('UnifiedRouter');
-
-// ===== Types =====
-
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-export type RouteHandler<T = any> = (req: HttpRequest, res: HttpResponse) => T | Promise<T>;
-export type Middleware = (
-  req: HttpRequest,
-  res: HttpResponse,
-  next: () => void
-) => void | Promise<void>;
-
-export interface ValidationConfig {
-  body?: ValidationSchema;
-  query?: ValidationSchema;
-  params?: ValidationSchema;
-  headers?: ValidationSchema;
-}
-
-export interface AuthConfig {
-  roles?: string[];
-  permissions?: string[];
-  optional?: boolean;
-}
-
-export interface RateLimitConfig {
-  requests: number;
-  window: number;
-  skipSuccessfulRequests?: boolean;
-}
-
-export interface CacheConfig {
-  ttl: number;
-  key?: string;
-  tags?: string[];
-}
-
-export interface MiddlewarePhases {
-  before?: Middleware[];
-  after?: Middleware[];
-  transform?: Middleware[];
-}
-
-export interface RouteSchema {
-  method: HttpMethod;
-  path: string;
-  handler: RouteHandler;
-  validation?: ValidationConfig;
-  auth?: AuthConfig;
-  rateLimit?: RateLimitConfig;
-  cache?: CacheConfig;
-  middleware?: MiddlewarePhases | Middleware[];
-  description?: string;
-  tags?: string[];
-}
-
-// Internal route representation
-interface InternalRoute {
-  schema: RouteSchema;
-  compiledPath: CompiledPath;
-  isFastPath: boolean; // No middleware, auth, validation, rate limiting
-  executionOrder: string[]; // Ordered list of execution phases
-}
-
-// ===== Route Builder (Chainable API) =====
-
-export class RouteBuilder {
-  private schema: Partial<RouteSchema>;
-  private router: UnifiedRouter;
-
-  constructor(method: HttpMethod, path: string, router: UnifiedRouter) {
-    this.schema = {
-      method,
-      path,
-      middleware: {} as MiddlewarePhases,
-    };
-    this.router = router;
-  }
-
-  // Validation methods
-  validate(config: ValidationConfig): this {
-    this.schema.validation = { ...this.schema.validation, ...config };
-    return this;
-  }
-
-  body<T>(schema: ValidationSchema<T>): this {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.body = schema;
-    return this;
-  }
-
-  query<T>(schema: ValidationSchema<T>): this {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.query = schema;
-    return this;
-  }
-
-  params<T>(schema: ValidationSchema<T>): this {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.params = schema;
-    return this;
-  }
-
-  headers<T>(schema: ValidationSchema<T>): this {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.headers = schema;
-    return this;
-  }
-
-  // Security methods
-  auth(config: AuthConfig): this {
-    this.schema.auth = config;
-    return this;
-  }
-
-  rateLimit(config: RateLimitConfig): this {
-    this.schema.rateLimit = config;
-    return this;
-  }
-
-  // Caching
-  cache(config: CacheConfig): this {
-    this.schema.cache = config;
-    return this;
-  }
-
-  // Custom middleware
-  before(...middleware: Middleware[]): this {
-    if (!this.schema.middleware) this.schema.middleware = {};
-    const phases = this.schema.middleware as MiddlewarePhases;
-    phases.before = [...(phases.before || []), ...middleware];
-    return this;
-  }
-
-  after(...middleware: Middleware[]): this {
-    if (!this.schema.middleware) this.schema.middleware = {};
-    const phases = this.schema.middleware as MiddlewarePhases;
-    phases.after = [...(phases.after || []), ...middleware];
-    return this;
-  }
-
-  transform(...middleware: Middleware[]): this {
-    if (!this.schema.middleware) this.schema.middleware = {};
-    const phases = this.schema.middleware as MiddlewarePhases;
-    phases.transform = [...(phases.transform || []), ...middleware];
-    return this;
-  }
-
-  use(...middleware: Middleware[]): this {
-    return this.after(...middleware);
-  }
-
-  // Metadata
-  describe(description: string): this {
-    this.schema.description = description;
-    return this;
-  }
-
-  tag(...tags: string[]): this {
-    this.schema.tags = [...(this.schema.tags || []), ...tags];
-    return this;
-  }
-
-  // Terminal method
-  handler<T>(handler: RouteHandler<T>): void {
-    if (!handler) {
-      throw new Error('Handler is required');
-    }
-
-    const completeSchema: RouteSchema = {
-      ...(this.schema as RouteSchema),
-      handler,
-    };
-
-    this.router.registerRoute(completeSchema);
-  }
-}
-
-// ===== Unified Router =====
-
-export class UnifiedRouter {
-  private static instance: UnifiedRouter | null = null;
-
-  private readonly poolManager = ObjectPoolManager.getInstance();
-
-  // Route storage optimized for different access patterns
-  private staticRoutes = new Map<string, InternalRoute>(); // O(1) lookup: "GET:/api/users"
-  private dynamicRoutesBySegments = new Map<number, InternalRoute[]>(); // Grouped by segment count
-  private fastPathRoutes = new Set<InternalRoute>(); // Routes with no middleware
-  private allRoutes: InternalRoute[] = []; // For iteration/inspection
-
-  // Statistics
-  private stats = {
-    totalRoutes: 0,
-    staticRoutes: 0,
-    dynamicRoutes: 0,
-    fastPathRoutes: 0,
-    requestCount: 0,
-    fastPathHits: 0,
-    staticHits: 0,
-    dynamicHits: 0,
-    cacheHits: 0,
-  };
-
-  constructor() {
-    logger.debug('UnifiedRouter initialized', 'Initialization');
-  }
-
-  /**
-   * Get singleton instance (optional - can still create new instances)
-   */
-  static getInstance(): UnifiedRouter {
-    if (!this.instance) {
-      this.instance = new UnifiedRouter();
-      logger.info(`UnifiedRouter initialized (PID: ${process.pid})`, 'Router');
-    }
-    return this.instance;
-  }
-
-  /**
-   * Reset singleton (useful for testing)
-   */
-  static reset(): void {
-    if (this.instance) {
-      this.instance.clearAllRoutes();
-    }
-    this.instance = null;
-  }
-
-  /**
-   * Clear all routes (useful for testing)
-   */
-  clearAllRoutes(): void {
-    this.staticRoutes.clear();
-    this.dynamicRoutesBySegments.clear();
-    this.fastPathRoutes.clear();
-    this.allRoutes = [];
-    this.stats = {
-      totalRoutes: 0,
-      staticRoutes: 0,
-      dynamicRoutes: 0,
-      fastPathRoutes: 0,
-      requestCount: 0,
-      fastPathHits: 0,
-      staticHits: 0,
-      dynamicHits: 0,
-      cacheHits: 0,
-    };
-    logger.debug('UnifiedRouter routes cleared', 'Reset');
-  }
-
-  // ===== Route Registration =====
-
-  /**
-   * Register a route (internal method)
-   */
-  registerRoute(schema: RouteSchema): void {
-    // Compile path pattern
-    const compiledPath = PathMatcher.compile(schema.path);
-
-    // Determine if this is a fast-path route
-    const isFastPath = this.isFastPathRoute(schema);
-
-    // Determine execution order
-    const executionOrder = this.buildExecutionOrder(schema);
-
-    const route: InternalRoute = {
-      schema,
-      compiledPath,
-      isFastPath,
-      executionOrder,
-    };
-
-    // Store in appropriate structures
-    if (compiledPath.isStatic) {
-      const key = `${schema.method}:${schema.path}`;
-      this.staticRoutes.set(key, route);
-      this.stats.staticRoutes++;
-    } else {
-      // Group by segment count for faster matching
-      const segmentCount = compiledPath.segments;
-      if (!this.dynamicRoutesBySegments.has(segmentCount)) {
-        this.dynamicRoutesBySegments.set(segmentCount, []);
-      }
-      this.dynamicRoutesBySegments.get(segmentCount)!.push(route);
-      this.stats.dynamicRoutes++;
-    }
-
-    if (isFastPath) {
-      this.fastPathRoutes.add(route);
-      this.stats.fastPathRoutes++;
-    }
-
-    this.allRoutes.push(route);
-    this.stats.totalRoutes++;
-
-    logger.info(
-      `Registered route: ${schema.method} ${schema.path} (PID: ${process.pid}, total: ${this.stats.totalRoutes})`,
-      'Registration',
-      {
-        isStatic: compiledPath.isStatic,
-        isFastPath,
-        segments: compiledPath.segments,
-      }
-    );
-  }
-
-  /**
-   * Chainable API methods
-   */
-  get(path: string): RouteBuilder {
-    return new RouteBuilder('GET', path, this);
-  }
-
-  post(path: string): RouteBuilder {
-    return new RouteBuilder('POST', path, this);
-  }
-
-  put(path: string): RouteBuilder {
-    return new RouteBuilder('PUT', path, this);
-  }
-
-  delete(path: string): RouteBuilder {
-    return new RouteBuilder('DELETE', path, this);
-  }
-
-  patch(path: string): RouteBuilder {
-    return new RouteBuilder('PATCH', path, this);
-  }
-
-  head(path: string): RouteBuilder {
-    return new RouteBuilder('HEAD', path, this);
-  }
-
-  options(path: string): RouteBuilder {
-    return new RouteBuilder('OPTIONS', path, this);
-  }
-
-  /**
-   * Schema-first route registration
-   */
-  route(schema: RouteSchema): void {
-    this.registerRoute(schema);
-  }
-
-  /**
-   * Direct API (for backward compatibility)
-   */
-  addRoute(
-    method: HttpMethod,
-    path: string,
-    handler: RouteHandler,
-    middleware: Middleware[] = []
-  ): void {
-    this.registerRoute({
-      method,
-      path,
-      handler,
-      middleware,
-    });
-  }
-
-  // ===== Route Matching =====
-
-  /**
-   * Find a matching route for the request
-   * Returns boolean (sync) for fast-path routes, Promise<boolean> for others
-   */
-  handleRequest(req: HttpRequest, res: HttpResponse): Promise<boolean> | boolean {
-    // PERFORMANCE: Only increment stats counter, not individual metrics in hot path
-    this.stats.requestCount++;
-
-    const method = req.method?.toUpperCase() as HttpMethod;
-    const path = req.path;
-
-    // Phase 1: No middleware, auth, validation, or rate limiting
-    // Optimized for synchronous execution when possible
-    if (this.fastPathRoutes.size > 0) {
-      for (const route of this.fastPathRoutes) {
-        if (route.schema.method === method) {
-          // Inline parameter extraction for speed (avoid function call overhead)
-          if (route.compiledPath.isStatic) {
-            if (route.compiledPath.path === path) {
-              // Static route match
-              req.params = {};
-
-              try {
-                const result = route.schema.handler(req, res);
-
-                // Check if result is a promise (optimized check)
-                if (result && typeof (result as any).then === 'function') {
-                  // Async handler - return promise
-                  return (result as Promise<any>)
-                    .then(actualResult => {
-                      if (actualResult !== undefined && !res.headersSent) {
-                        res.json(actualResult);
-                      }
-                      return true;
-                    })
-                    .catch(() => {
-                      if (!res.headersSent) {
-                        res.status(500).json({ error: 'Internal server error' });
-                      }
-                      return true;
-                    });
-                } else {
-                  // Sync handler - handle synchronously (fastest path!)
-                  if (result !== undefined && !res.headersSent) {
-                    res.json(result);
-                  }
-                  return true;
-                }
-              } catch (error) {
-                if (!res.headersSent) {
-                  res.status(500).json({ error: 'Internal server error' });
-                }
-                return true;
-              }
-            }
-          } else {
-            // Dynamic route - use regex matching
-            const pattern = route.compiledPath.pattern;
-            if (pattern) {
-              const matches = path.match(pattern);
-              if (matches) {
-                // Extract params inline (avoid function call)
-                const params: Record<string, string> = {};
-                const paramNames = route.compiledPath.paramNames;
-                for (let i = 0; i < paramNames.length; i++) {
-                  params[paramNames[i]] = matches[i + 1];
-                }
-                req.params = params;
-
-                try {
-                  const result = route.schema.handler(req, res);
-
-                  if (result && typeof (result as any).then === 'function') {
-                    return (result as Promise<any>)
-                      .then(actualResult => {
-                        if (actualResult !== undefined && !res.headersSent) {
-                          res.json(actualResult);
-                        }
-                        return true;
-                      })
-                      .catch(() => {
-                        if (!res.headersSent) {
-                          res.status(500).json({ error: 'Internal server error' });
-                        }
-                        return true;
-                      });
-                  } else {
-                    if (result !== undefined && !res.headersSent) {
-                      res.json(result);
-                    }
-                    return true;
-                  }
-                } catch (error) {
-                  if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                  }
-                  return true;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // Phase 2 & 3: Non-fast-path routes (async)
-    return (async () => {
-      // Phase 2: O(1) static route lookup
-      const staticKey = `${method}:${path}`;
-
-      // Check pool manager cache
-      const cachedRoute = this.poolManager.getCachedRoute(staticKey);
-      if (cachedRoute) {
-        await this.executeRoute(cachedRoute, req, res, { params: {} });
-        return true;
-      }
-
-      const staticRoute = this.staticRoutes.get(staticKey);
-      if (staticRoute) {
-        this.poolManager.cacheRoute(staticKey, staticRoute);
-        req.params = {};
-        await this.executeRoute(staticRoute, req, res, { params: {} });
-        return true;
-      }
-
-      // Phase 3: Segment-based dynamic route matching
-      const segments = path.split('/').filter(s => s.length > 0);
-      const segmentCount = segments.length;
-      const candidates = this.dynamicRoutesBySegments.get(segmentCount) || [];
-
-      for (const route of candidates) {
-        if (route.schema.method === method) {
-          const matchResult = PathMatcher.match(route.compiledPath, path);
-          if (matchResult) {
-            this.poolManager.cacheRoute(staticKey, route);
-            await this.executeRoute(route, req, res, matchResult);
-            return true;
-          }
-        }
-      }
-
-      // No route found
-      return false;
-    })();
-  }
-
-  // ===== Route Execution =====
-
-  private async executeRoute(
-    route: InternalRoute,
-    req: HttpRequest,
-    res: HttpResponse,
-    matchResult: { params: Record<string, string> }
-  ): Promise<void> {
-    // Set params from pool
-    req.params = this.poolManager.acquireParams();
-    Object.assign(req.params, matchResult.params);
-
-    try {
-      // Execute middleware phases in order
-      for (const phase of route.executionOrder) {
-        if (res.headersSent) break;
-        await this.executePhase(phase, route, req, res);
-      }
-
-      // Execute handler
-      if (!res.headersSent) {
-        const result = await route.schema.handler(req, res);
-        if (result !== undefined && !res.headersSent) {
-          await res.json(result);
-        }
-      }
-    } catch (error) {
-      logger.error('Route execution error', 'Execution', {
-        error: error instanceof Error ? error.message : String(error),
-        route: `${route.schema.method} ${route.schema.path}`,
-      });
-
-      if (!res.headersSent) {
-        res.status(500).json({
-          success: false,
-          error: 'Internal server error',
-          requestId: req.requestId,
-        });
-      }
-    } finally {
-      // Release params back to pool
-      if (req.params) {
-        this.poolManager.releaseParams(req.params);
-      }
-    }
-  }
-
-  private async executePhase(
-    phase: string,
-    route: InternalRoute,
-    req: HttpRequest,
-    res: HttpResponse
-  ): Promise<void> {
-    const schema = route.schema;
-    const middleware = schema.middleware;
-
-    switch (phase) {
-      case 'before':
-        if (middleware && 'before' in middleware && Array.isArray(middleware.before)) {
-          for (const mw of middleware.before) {
-            await this.executeMiddleware(mw, req, res);
-            if (res.headersSent) return;
-          }
-        }
-        break;
-
-      case 'rateLimit':
-        if (schema.rateLimit) {
-          await this.executeRateLimit(req, res, schema.rateLimit);
-        }
-        break;
-
-      case 'auth':
-        if (schema.auth) {
-          await this.executeAuth(req, res, schema.auth);
-        }
-        break;
-
-      case 'validation':
-        if (schema.validation) {
-          await this.executeValidation(req, res, schema.validation);
-        }
-        break;
-
-      case 'transform':
-        if (middleware && 'transform' in middleware && Array.isArray(middleware.transform)) {
-          for (const mw of middleware.transform) {
-            await this.executeMiddleware(mw, req, res);
-            if (res.headersSent) return;
-          }
-        }
-        break;
-
-      case 'cache':
-        if (schema.cache) {
-          await this.executeCache(req, res, schema.cache);
-        }
-        break;
-
-      case 'after':
-        if (middleware && 'after' in middleware && Array.isArray(middleware.after)) {
-          for (const mw of middleware.after) {
-            await this.executeMiddleware(mw, req, res);
-            if (res.headersSent) return;
-          }
-        }
-        break;
-
-      case 'middleware':
-        // Handle array-style middleware (backward compatibility)
-        if (middleware && Array.isArray(middleware)) {
-          for (const mw of middleware) {
-            await this.executeMiddleware(mw, req, res);
-            if (res.headersSent) return;
-          }
-        }
-        break;
-    }
-  }
-
-  private async executeMiddleware(
-    middleware: Middleware,
-    req: HttpRequest,
-    res: HttpResponse
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-
-      const next = () => {
-        if (!resolved) {
-          resolved = true;
-          resolve();
-        }
-      };
-
-      try {
-        const result = middleware(req, res, next);
-        if (result instanceof Promise) {
-          result.then(() => !resolved && next()).catch(reject);
-        } else if (!resolved) {
-          next();
-        }
-      } catch (error) {
-        if (!resolved) {
-          resolved = true;
-          reject(error);
-        }
-      }
-    });
-  }
-
-  private async executeRateLimit(
-    _req: HttpRequest,
-    _res: HttpResponse,
-    _config: RateLimitConfig
-  ): Promise<void> {
-    // Rate limiting implementation placeholder
-    // TODO: Implement actual rate limiting logic
-  }
-
-  private async executeAuth(
-    req: HttpRequest,
-    res: HttpResponse,
-    config: AuthConfig
-  ): Promise<void> {
-    const auth = (req as any).auth;
-
-    if (!auth) {
-      res.status(500).json({
-        success: false,
-        error: 'Authentication middleware not configured',
-      });
-      return;
-    }
-
-    if (!config.optional && !auth.isAuthenticated) {
-      res.status(401).json({
-        success: false,
-        error: 'Authentication required',
-      });
-      return;
-    }
-
-    if (auth.isAuthenticated && config.roles) {
-      const userRoles = auth.user?.roles || [];
-      const hasRole = config.roles.some(role => userRoles.includes(role));
-      if (!hasRole) {
-        res.status(403).json({
-          success: false,
-          error: 'Insufficient permissions',
-          message: `Required roles: ${config.roles.join(', ')}`,
-        });
-        return;
-      }
-    }
-
-    if (auth.isAuthenticated && config.permissions) {
-      const userPermissions = auth.user?.permissions || [];
-      const hasPermission = config.permissions.every(permission =>
-        userPermissions.includes(permission)
-      );
-      if (!hasPermission) {
-        res.status(403).json({
-          success: false,
-          error: 'Insufficient permissions',
-          message: `Required permissions: ${config.permissions.join(', ')}`,
-        });
-        return;
-      }
-    }
-  }
-
-  private async executeValidation(
-    req: HttpRequest,
-    res: HttpResponse,
-    config: ValidationConfig
-  ): Promise<void> {
-    try {
-      if (config.body && req.body !== undefined) {
-        (req as any).validatedBody = await config.body.parseAsync(req.body);
-        req.body = (req as any).validatedBody;
-      }
-
-      if (config.query && req.query !== undefined) {
-        (req as any).validatedQuery = await config.query.parseAsync(req.query);
-        req.query = (req as any).validatedQuery;
-      }
-
-      if (config.params && req.params !== undefined) {
-        (req as any).validatedParams = await config.params.parseAsync(req.params);
-        req.params = (req as any).validatedParams;
-      }
-
-      if (config.headers && req.headers !== undefined) {
-        (req as any).validatedHeaders = await config.headers.parseAsync(req.headers);
-      }
-    } catch (error: any) {
-      const field = error.field || 'unknown';
-      if (error.issues) {
-        res.status(400).json({
-          success: false,
-          error: `Validation failed for ${field}`,
-          details: error.issues.map((issue: any) => ({
-            field: issue.path.length > 0 ? issue.path.join('.') : field,
-            message: issue.message,
-            code: issue.code,
-          })),
-          requestId: req.requestId,
-        });
-      } else {
-        res.status(400).json({
-          success: false,
-          error: `Validation failed for ${field}`,
-          requestId: req.requestId,
-        });
-      }
-    }
-  }
-
-  private async executeCache(
-    _req: HttpRequest,
-    _res: HttpResponse,
-    _config: CacheConfig
-  ): Promise<void> {
-    // Cache implementation placeholder
-    // TODO: Implement actual caching logic
-  }
-
-  // ===== Helper Methods =====
-
-  private isFastPathRoute(schema: RouteSchema): boolean {
-    const middleware = schema.middleware;
-    const hasMiddleware =
-      (middleware && Array.isArray(middleware) && middleware.length > 0) ||
-      (middleware &&
-        typeof middleware === 'object' &&
-        ((middleware as MiddlewarePhases).before?.length ||
-          (middleware as MiddlewarePhases).after?.length ||
-          (middleware as MiddlewarePhases).transform?.length));
-
-    return (
-      !schema.auth && !schema.validation && !schema.rateLimit && !schema.cache && !hasMiddleware
-    );
-  }
-
-  private buildExecutionOrder(schema: RouteSchema): string[] {
-    const order: string[] = [];
-    const middleware = schema.middleware;
-
-    // Phase-based middleware
-    if (middleware && 'before' in middleware && middleware.before?.length) {
-      order.push('before');
-    }
-
-    if (schema.rateLimit) order.push('rateLimit');
-    if (schema.auth) order.push('auth');
-    if (schema.validation) order.push('validation');
-
-    if (middleware && 'transform' in middleware && middleware.transform?.length) {
-      order.push('transform');
-    }
-
-    if (schema.cache) order.push('cache');
-
-    if (middleware && 'after' in middleware && middleware.after?.length) {
-      order.push('after');
-    }
-
-    // Array-style middleware (backward compatibility)
-    if (middleware && Array.isArray(middleware) && middleware.length > 0) {
-      order.push('middleware');
-    }
-
-    return order;
-  }
-
-  // ===== Inspection Methods =====
-
-  getAllRoutes(): RouteSchema[] {
-    return this.allRoutes.map(r => r.schema);
-  }
-
-  getRouteCount(): number {
-    return this.stats.totalRoutes;
-  }
-
-  getStats() {
-    return {
-      ...this.stats,
-      poolManager: this.poolManager.getPerformanceSummary(),
-      pathMatcher: PathMatcher.getStats(),
-    };
-  }
-
-  logPerformanceStats(): void {
-    const stats = this.getStats();
-    logger.info('UnifiedRouter Performance', 'Stats', {
-      totalRoutes: stats.totalRoutes,
-      staticRoutes: stats.staticRoutes,
-      dynamicRoutes: stats.dynamicRoutes,
-      fastPathRoutes: stats.fastPathRoutes,
-      requests: stats.requestCount,
-      poolManager: {
-        routeCacheHitRate: stats.poolManager.routeCacheHitRate.toFixed(1) + '%',
-        responseCacheHitRate: stats.poolManager.responseCacheHitRate.toFixed(1) + '%',
-        paramPoolUtilization: stats.poolManager.paramPoolUtilization.toFixed(1) + '%',
-        totalMemoryKB: stats.poolManager.totalMemoryKB.toFixed(1) + ' KB',
-      },
-    });
-  }
-}