expressed-core 1.0.0

package/router/RouteMatcher.js

@@ -0,0 +1,361 @@
+/**
+ * Componente especializado para la lógica de enrutado optimizado en Express
+ * Implementación del componente router/RouteMatcher.js para Express
+ * Express-Router v1.0.0 - Optimización de rendimiento con índices y pre-filtrado
+ */
+
+class RouteMatcher {
+  /**
+   * Constructor del matcher de rutas optimizado
+   */
+  constructor() {
+    // Cache de expresiones regulares para rutas parametrizadas
+    this.routeRegexCache = new Map();
+
+    // Índices para optimización
+    this.exactRoutes = new Map(); // Rutas exactas indexadas por método y path
+    this.routeBuckets = {}; // Rutas organizadas por método, número de segmentos y primer segmento
+    this.indexesValid = false;
+
+    // Referencia al sistema de hooks (se establecerá externamente)
+    this.hooks = null;
+  }
+
+  /**
+   * Actualiza los índices basados en el conjunto actual de rutas
+   * @param {Array} routes - Array de rutas registradas
+   */
+  updateIndexes(routes) {
+    // Limpiar índices existentes
+    this.exactRoutes.clear();
+    this.routeBuckets = {};
+
+    // Reconstruir índices
+    for (const route of routes) {
+      // Indexar rutas exactas
+      const methodPathKey = `${route.method}:${route.path}`;
+      this.exactRoutes.set(methodPathKey, route);
+
+      // Organizar rutas en buckets por método, número de segmentos y primer segmento
+      const segments = route.path.split('/').filter(s => s !== '');
+      const segmentCount = segments.length;
+      const firstSegment = segments.length > 0 ? segments[0] : '';
+
+      // Inicializar estructura de buckets si no existe
+      if (!this.routeBuckets[route.method]) {
+        this.routeBuckets[route.method] = {};
+      }
+      if (!this.routeBuckets[route.method][segmentCount]) {
+        this.routeBuckets[route.method][segmentCount] = {};
+      }
+      if (!this.routeBuckets[route.method][segmentCount][firstSegment]) {
+        this.routeBuckets[route.method][segmentCount][firstSegment] = [];
+      }
+
+      // Agregar ruta al bucket correspondiente
+      this.routeBuckets[route.method][segmentCount][firstSegment].push(route);
+    }
+
+    this.indexesValid = true;
+  }
+
+  /**
+   * Método para encontrar una ruta coincidente con optimizaciones
+   * @param {Array} routes - Array de rutas registradas
+   * @param {string} method - Método HTTP
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Objeto de ruta encontrado o null
+   */
+  findRoute(routes, method, pathname) {
+    // Actualizar índices si es necesario
+    if (!this.indexesValid || routes.length !== this.getStoredRoutesCount()) {
+      this.updateIndexes(routes);
+    }
+
+    // Búsqueda por ruta exacta (más rápida)
+    const exactMatch = this.findExactMatch(method, pathname);
+    if (exactMatch) {
+      return {
+        route: exactMatch,
+        params: {}
+      };
+    }
+
+    // Pre-filtrar rutas candidatas usando índices
+    const pathnameSegments = pathname.split('/').filter(s => s !== '');
+    const segmentCount = pathnameSegments.length;
+    const firstSegment = pathnameSegments.length > 0 ? pathnameSegments[0] : '';
+
+    // Obtener rutas candidatas basadas en número de segmentos y primer segmento
+    const candidateRoutes = this.getCandidateRoutes(method, segmentCount, firstSegment, pathname);
+
+    // Buscar rutas estáticas que coincidan exactamente
+    const staticExactMatch = this.findStaticExactMatch(candidateRoutes, pathname);
+    if (staticExactMatch) {
+      return {
+        route: staticExactMatch,
+        params: {}
+      };
+    }
+
+    // Buscar rutas parametrizadas entre los candidatos
+    const parametrizedMatch = this.findParametrizedMatch(candidateRoutes, pathname);
+    if (parametrizedMatch) {
+      return parametrizedMatch;
+    }
+
+    // Buscar rutas estáticas (prefijos) entre los candidatos
+    const staticPrefixMatch = this.findStaticPrefixMatch(candidateRoutes, pathname);
+    if (staticPrefixMatch) {
+      return staticPrefixMatch;
+    }
+
+    return null;
+  }
+
+  /**
+   * Busca rutas exactas usando el índice
+   * @param {string} method - Método HTTP
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta exacta encontrada o null
+   */
+  findExactMatch(method, pathname) {
+    const methodPathKey = `${method}:${pathname}`;
+    return this.exactRoutes.get(methodPathKey) || null;
+  }
+
+  /**
+   * Obtiene rutas candidatas basadas en número de segmentos y primer segmento
+   * @param {string} method - Método HTTP
+   * @param {number} segmentCount - Número de segmentos de la ruta buscada
+   * @param {string} firstSegment - Primer segmento de la ruta buscada
+   * @param {string} pathname - Ruta completa buscada
+   * @returns {Array} - Array de rutas candidatas
+   */
+  getCandidateRoutes(method, segmentCount, firstSegment, pathname) {
+    const candidates = [];
+
+    // Si existe un bucket para este método, número de segmentos y primer segmento
+    if (this.routeBuckets[method] &&
+        this.routeBuckets[method][segmentCount] &&
+        this.routeBuckets[method][segmentCount][firstSegment]) {
+      candidates.push(...this.routeBuckets[method][segmentCount][firstSegment]);
+    }
+
+    // También agregar rutas de otros primeros segmentos para este método y número de segmentos
+    if (this.routeBuckets[method] && this.routeBuckets[method][segmentCount]) {
+      for (const segment in this.routeBuckets[method][segmentCount]) {
+        if (segment !== firstSegment) {
+          candidates.push(...this.routeBuckets[method][segmentCount][segment]);
+        }
+      }
+    }
+
+    // Agregar rutas estáticas que podrían coincidir por prefijo
+    if (this.routeBuckets[method]) {
+      for (const count in this.routeBuckets[method]) {
+        for (const segment in this.routeBuckets[method][count]) {
+          const routes = this.routeBuckets[method][count][segment];
+          for (const route of routes) {
+            if (route.isStatic && pathname.startsWith(route.path)) {
+              candidates.push(route);
+            }
+          }
+        }
+      }
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Busca rutas estáticas con coincidencia exacta entre candidatos
+   * @param {Array} candidateRoutes - Rutas candidatas
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta estática exacta encontrada o null
+   */
+  findStaticExactMatch(candidateRoutes, pathname) {
+    for (const route of candidateRoutes) {
+      if (route.isStatic && route.path === pathname) {
+        return route;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Busca rutas parametrizadas entre candidatos
+   * @param {Array} candidateRoutes - Rutas candidatas
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta parametrizada encontrada o null
+   */
+  findParametrizedMatch(candidateRoutes, pathname) {
+    for (const route of candidateRoutes) {
+      if (this.isParametrizedRoute(route.path)) {
+        // Convertir ruta parametrizada a expresión regular
+        const routeRegex = this.pathToRegex(route.path);
+        const match = pathname.match(routeRegex);
+
+        if (match) {
+          const params = this.extractParams(route.path, pathname);
+          return {
+            route: route,
+            params: params
+          };
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Busca rutas estáticas por prefijo entre candidatos
+   * @param {Array} candidateRoutes - Rutas candidatas
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta estática por prefijo encontrada o null
+   */
+  findStaticPrefixMatch(candidateRoutes, pathname) {
+    const staticMatches = [];
+    for (const route of candidateRoutes) {
+      if (route.isStatic && pathname.startsWith(route.path)) {
+        // Verificar que sea exactamente el prefijo o que haya una barra después del prefijo
+        const remainingPath = pathname.substring(route.path.length);
+        if (route.path === '/' || remainingPath === '' || remainingPath.startsWith('/')) {
+          staticMatches.push({
+            route: route,
+            params: {},
+            specificity: route.path.length  // Agregar medida de especificidad basada en longitud del prefijo
+          });
+        }
+      }
+    }
+
+    if (staticMatches.length > 0) {
+      // Ordenar por especificidad (longitud del prefijo, descendente) y tomar la más específica
+      staticMatches.sort((a, b) => b.specificity - a.specificity);
+      return staticMatches[0];
+    }
+
+    return null;
+  }
+
+  /**
+   * Determina si una ruta es parametrizada
+   * @param {string} path - Ruta a verificar
+   * @returns {boolean} - True si la ruta contiene parámetros
+   */
+  isParametrizedRoute(path) {
+    return path.includes(':');
+  }
+
+  /**
+   * Obtiene el conteo total de rutas almacenadas en índices
+   * @returns {number} - Número total de rutas indexadas
+   */
+  getStoredRoutesCount() {
+    let count = 0;
+    for (const method in this.routeBuckets) {
+      for (const segmentCount in this.routeBuckets[method]) {
+        for (const firstSegment in this.routeBuckets[method][segmentCount]) {
+          count += this.routeBuckets[method][segmentCount][firstSegment].length;
+        }
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Convierte una ruta con parámetros a expresión regular
+   * @param {string} path - Ruta con posibles parámetros
+   * @returns {RegExp} - Expresión regular para la ruta
+   */
+  pathToRegex(path) {
+    // Verificar si ya está en caché
+    if (this.routeRegexCache.has(path)) {
+      return this.routeRegexCache.get(path);
+    }
+
+    // Lógica de escape de caracteres especiales
+    let escapedPath = '';
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      if (char.match(/[.+?^${}()|[\]\\-]/) && !(i > 0 && path[i-1] === ':')) {
+        escapedPath += '\\' + char;
+      } else {
+        escapedPath += char;
+      }
+    }
+    // Reemplazar parámetros :param con grupos de captura no greedy para evitar problemas de matching
+    const regexPath = escapedPath.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+?)');
+    const regex = new RegExp(`^${regexPath}$`);
+
+    // Verificar con hook si se debe cachear esta expresión regular
+    const shouldCache = this.hooks ?
+      this.hooks.applyFilters('should_cache_route_regex', true, path, regex) : true;
+
+    if (shouldCache) {
+      // Almacenar en caché
+      this.routeRegexCache.set(path, regex);
+
+      // Disparar hook después de cachear
+      if (this.hooks) {
+        this.hooks.doAction('route_regex_cached', path, regex);
+      }
+    }
+
+    return regex;
+  }
+
+  /**
+   * Extrae los parámetros de una ruta parametrizada
+   * @param {string} routePath - Ruta con parámetros (ej. /users/:id)
+   * @param {string} actualPath - Ruta real solicitada
+   * @returns {Object} - Objeto con los parámetros extraídos
+   */
+  extractParams(routePath, actualPath) {
+    const params = {};
+
+    // Expresión regular para encontrar parámetros en la ruta
+    const paramNames = [];
+    const paramNameRegex = /:([a-zA-Z0-9_]+)/g;
+    let match;
+
+    while ((match = paramNameRegex.exec(routePath)) !== null) {
+      paramNames.push(match[1]);
+    }
+
+    // Crear expresión regular para extraer valores
+    const routeRegex = this.pathToRegex(routePath);
+    const values = actualPath.match(routeRegex);
+
+    if (values) {
+      // El primer elemento es la cadena completa, los demás son los valores capturados
+      for (let i = 0; i < paramNames.length; i++) {
+        if (values[i + 1]) {
+          params[paramNames[i]] = values[i + 1];
+        }
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * Limpia el caché de expresiones regulares
+   */
+  clearCache() {
+    // Disparar hook antes de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('before_route_regex_cache_clear', this);
+    }
+
+    this.routeRegexCache.clear();
+
+    // Disparar hook después de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('route_regex_cache_cleared');
+    }
+  }
+}
+
+module.exports = RouteMatcher;