@push.rocks/smartproxy 19.5.19 → 19.5.20

package/ts/routing/router/route-router.ts

@@ -1,482 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-import type { ILogger } from '../../proxies/http-proxy/models/types.js';
-
-/**
- * Optional path pattern configuration that can be added to proxy configs
- */
-export interface PathPatternConfig {
-  pathPattern?: string;
-}
-
-/**
- * Interface for router result with additional metadata
- */
-export interface RouterResult {
-  route: IRouteConfig;
-  pathMatch?: string;
-  pathParams?: Record<string, string>;
-  pathRemainder?: string;
-}
-
-/**
- * Router for HTTP reverse proxy requests based on route configurations
- * 
- * Supports the following domain matching patterns:
- * - Exact matches: "example.com"
- * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
- * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
- * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
- * - Default fallback: "*" (matches any unmatched domain)
- * 
- * Also supports path pattern matching for each domain:
- * - Exact path: "/api/users"
- * - Wildcard paths: "/api/*" 
- * - Path parameters: "/users/:id/profile"
- */
-export class RouteRouter {
-  // Store original routes for reference
-  private routes: IRouteConfig[] = [];
-  // Default route to use when no match is found (optional)
-  private defaultRoute?: IRouteConfig;
-  // Store path patterns separately since they're not in the original interface
-  private pathPatterns: Map<IRouteConfig, string> = new Map();
-  // Logger interface
-  private logger: ILogger;
-
-  constructor(
-    routes?: IRouteConfig[],
-    logger?: ILogger
-  ) {
-    this.logger = logger || {
-      error: console.error,
-      warn: console.warn,
-      info: console.info,
-      debug: console.debug
-    };
-    
-    if (routes) {
-      this.setRoutes(routes);
-    }
-  }
-
-  /**
-   * Sets a new set of routes to be routed to
-   * @param routes Array of route configurations
-   */
-  public setRoutes(routes: IRouteConfig[]): void {
-    this.routes = [...routes];
-
-    // Sort routes by priority
-    this.routes.sort((a, b) => {
-      const priorityA = a.priority ?? 0;
-      const priorityB = b.priority ?? 0;
-      return priorityB - priorityA;
-    });
-
-    // Find default route if any (route with "*" as domain)
-    this.defaultRoute = this.routes.find(route => {
-      const domains = Array.isArray(route.match.domains) 
-        ? route.match.domains 
-        : [route.match.domains];
-      return domains.includes('*');
-    });
-
-    // Extract path patterns from route match.path
-    for (const route of this.routes) {
-      if (route.match.path) {
-        this.pathPatterns.set(route, route.match.path);
-      }
-    }
-
-    const uniqueDomains = this.getHostnames();
-    this.logger.info(`Router initialized with ${this.routes.length} routes (${uniqueDomains.length} unique hosts)`);
-  }
-
-  /**
-   * Routes a request based on hostname and path
-   * @param req The incoming HTTP request
-   * @returns The matching route or undefined if no match found
-   */
-  public routeReq(req: plugins.http.IncomingMessage): IRouteConfig | undefined {
-    const result = this.routeReqWithDetails(req);
-    return result ? result.route : undefined;
-  }
-
-  /**
-   * Routes a request with detailed matching information
-   * @param req The incoming HTTP request
-   * @returns Detailed routing result including matched route and path information
-   */
-  public routeReqWithDetails(req: plugins.http.IncomingMessage): RouterResult | undefined {
-    // Extract and validate host header
-    const originalHost = req.headers.host;
-    if (!originalHost) {
-      this.logger.error('No host header found in request');
-      return this.defaultRoute ? { route: this.defaultRoute } : undefined;
-    }
-    
-    // Parse URL for path matching
-    const parsedUrl = plugins.url.parse(req.url || '/');
-    const urlPath = parsedUrl.pathname || '/';
-    
-    // Extract hostname without port
-    const hostWithoutPort = originalHost.split(':')[0].toLowerCase();
-    
-    // First try exact hostname match
-    const exactRoute = this.findRouteForHost(hostWithoutPort, urlPath);
-    if (exactRoute) {
-      return exactRoute;
-    }
-    
-    // Try various wildcard patterns
-    if (hostWithoutPort.includes('.')) {
-      const domainParts = hostWithoutPort.split('.');
-      
-      // Try wildcard subdomain (*.example.com)
-      if (domainParts.length > 2) {
-        const wildcardDomain = `*.${domainParts.slice(1).join('.')}`;
-        const wildcardRoute = this.findRouteForHost(wildcardDomain, urlPath);
-        if (wildcardRoute) {
-          return wildcardRoute;
-        }
-      }
-      
-      // Try TLD wildcard (example.*)
-      const baseDomain = domainParts.slice(0, -1).join('.');
-      const tldWildcardDomain = `${baseDomain}.*`;
-      const tldWildcardRoute = this.findRouteForHost(tldWildcardDomain, urlPath);
-      if (tldWildcardRoute) {
-        return tldWildcardRoute;
-      }
-
-      // Try complex wildcard patterns
-      const wildcardPatterns = this.findWildcardMatches(hostWithoutPort);
-      for (const pattern of wildcardPatterns) {
-        const wildcardRoute = this.findRouteForHost(pattern, urlPath);
-        if (wildcardRoute) {
-          return wildcardRoute;
-        }
-      }
-    }
-    
-    // Fall back to default route if available
-    if (this.defaultRoute) {
-      this.logger.warn(`No specific route found for host: ${hostWithoutPort}, using default`);
-      return { route: this.defaultRoute };
-    }
-    
-    this.logger.error(`No route found for host: ${hostWithoutPort}`);
-    return undefined;
-  }
-  
-  /**
-   * Find potential wildcard patterns that could match a given hostname
-   * Handles complex patterns like "*.lossless*" or other partial matches
-   * @param hostname The hostname to find wildcard matches for
-   * @returns Array of potential wildcard patterns that could match
-   */
-  private findWildcardMatches(hostname: string): string[] {
-    const patterns: string[] = [];
-    
-    // Find all routes with wildcard domains
-    for (const route of this.routes) {
-      if (!route.match.domains) continue;
-      
-      const domains = Array.isArray(route.match.domains) 
-        ? route.match.domains 
-        : [route.match.domains];
-      
-      // Filter to only wildcard domains
-      const wildcardDomains = domains.filter(domain => domain.includes('*'));
-      
-      // Convert each wildcard domain to a regex pattern and check if it matches
-      for (const domain of wildcardDomains) {
-        // Skip the default wildcard '*'
-        if (domain === '*') continue;
-        
-        // Skip already checked patterns (*.domain.com and domain.*)
-        if (domain.startsWith('*.') && domain.indexOf('*', 2) === -1) continue;
-        if (domain.endsWith('.*') && domain.indexOf('*') === domain.length - 1) continue;
-        
-        // Convert wildcard pattern to regex
-        const regexPattern = domain
-          .replace(/\./g, '\\.')  // Escape dots
-          .replace(/\*/g, '.*');  // Convert * to .* for regex
-        
-        // Create regex object with case insensitive flag
-        const regex = new RegExp(`^${regexPattern}$`, 'i');
-        
-        // If hostname matches this complex pattern, add it to the list
-        if (regex.test(hostname)) {
-          patterns.push(domain);
-        }
-      }
-    }
-    
-    return patterns;
-  }
-
-  /**
-   * Find a route for a specific host and path
-   */
-  private findRouteForHost(hostname: string, path: string): RouterResult | undefined {
-    // Find all routes for this hostname
-    const matchingRoutes = this.routes.filter(route => {
-      if (!route.match.domains) return false;
-      
-      const domains = Array.isArray(route.match.domains) 
-        ? route.match.domains 
-        : [route.match.domains];
-      
-      return domains.some(domain => domain.toLowerCase() === hostname.toLowerCase());
-    });
-    
-    if (matchingRoutes.length === 0) {
-      return undefined;
-    }
-    
-    // First try routes with path patterns
-    const routesWithPaths = matchingRoutes.filter(route => this.pathPatterns.has(route));
-    
-    // Already sorted by priority during setRoutes
-    
-    // Check each route with path pattern
-    for (const route of routesWithPaths) {
-      const pathPattern = this.pathPatterns.get(route);
-      if (pathPattern) {
-        const pathMatch = this.matchPath(path, pathPattern);
-        if (pathMatch) {
-          return {
-            route,
-            pathMatch: pathMatch.matched,
-            pathParams: pathMatch.params,
-            pathRemainder: pathMatch.remainder
-          };
-        }
-      }
-    }
-    
-    // If no path pattern matched, use the first route without a path pattern
-    const routeWithoutPath = matchingRoutes.find(route => !this.pathPatterns.has(route));
-    if (routeWithoutPath) {
-      return { route: routeWithoutPath };
-    }
-    
-    return undefined;
-  }
-  
-  /**
-   * Matches a URL path against a pattern
-   * Supports:
-   * - Exact matches: /users/profile
-   * - Wildcards: /api/* (matches any path starting with /api/)
-   * - Path parameters: /users/:id (captures id as a parameter)
-   * 
-   * @param path The URL path to match
-   * @param pattern The pattern to match against
-   * @returns Match result with params and remainder, or null if no match
-   */
-  private matchPath(path: string, pattern: string): { 
-    matched: string; 
-    params: Record<string, string>; 
-    remainder: string;
-  } | null {
-    // Handle exact match
-    if (path === pattern) {
-      return {
-        matched: pattern,
-        params: {},
-        remainder: ''
-      };
-    }
-    
-    // Handle wildcard match
-    if (pattern.endsWith('/*')) {
-      const prefix = pattern.slice(0, -2);
-      if (path === prefix || path.startsWith(`${prefix}/`)) {
-        return {
-          matched: prefix,
-          params: {},
-          remainder: path.slice(prefix.length)
-        };
-      }
-      return null;
-    }
-    
-    // Handle path parameters
-    const patternParts = pattern.split('/').filter(p => p);
-    const pathParts = path.split('/').filter(p => p);
-    
-    // Too few path parts to match
-    if (pathParts.length < patternParts.length) {
-      return null;
-    }
-    
-    const params: Record<string, string> = {};
-    
-    // Compare each part
-    for (let i = 0; i < patternParts.length; i++) {
-      const patternPart = patternParts[i];
-      const pathPart = pathParts[i];
-      
-      // Handle parameter
-      if (patternPart.startsWith(':')) {
-        const paramName = patternPart.slice(1);
-        params[paramName] = pathPart;
-        continue;
-      }
-      
-      // Handle wildcard at the end
-      if (patternPart === '*' && i === patternParts.length - 1) {
-        break;
-      }
-      
-      // Handle exact match for this part
-      if (patternPart !== pathPart) {
-        return null;
-      }
-    }
-    
-    // Calculate the remainder - the unmatched path parts
-    const remainderParts = pathParts.slice(patternParts.length);
-    const remainder = remainderParts.length ? '/' + remainderParts.join('/') : '';
-    
-    // Calculate the matched path
-    const matchedParts = patternParts.map((part, i) => {
-      return part.startsWith(':') ? pathParts[i] : part;
-    });
-    const matched = '/' + matchedParts.join('/');
-    
-    return {
-      matched,
-      params,
-      remainder
-    };
-  }
-  
-  /**
-   * Gets all currently active route configurations
-   * @returns Array of all active routes
-   */
-  public getRoutes(): IRouteConfig[] {
-    return [...this.routes];
-  }
-  
-  /**
-   * Gets all hostnames that this router is configured to handle
-   * @returns Array of hostnames
-   */
-  public getHostnames(): string[] {
-    const hostnames = new Set<string>();
-    for (const route of this.routes) {
-      if (!route.match.domains) continue;
-      
-      const domains = Array.isArray(route.match.domains) 
-        ? route.match.domains 
-        : [route.match.domains];
-      
-      for (const domain of domains) {
-        if (domain !== '*') {
-          hostnames.add(domain.toLowerCase());
-        }
-      }
-    }
-    return Array.from(hostnames);
-  }
-  
-  /**
-   * Adds a single new route configuration
-   * @param route The route configuration to add
-   */
-  public addRoute(route: IRouteConfig): void {
-    this.routes.push(route);
-    
-    // Store path pattern if present
-    if (route.match.path) {
-      this.pathPatterns.set(route, route.match.path);
-    }
-    
-    // Re-sort routes by priority
-    this.routes.sort((a, b) => {
-      const priorityA = a.priority ?? 0;
-      const priorityB = b.priority ?? 0;
-      return priorityB - priorityA;
-    });
-  }
-  
-  /**
-   * Removes routes by domain pattern
-   * @param domain The domain pattern to remove routes for
-   * @returns Boolean indicating whether any routes were removed
-   */
-  public removeRoutesByDomain(domain: string): boolean {
-    const initialCount = this.routes.length;
-    
-    // Find routes to remove
-    const routesToRemove = this.routes.filter(route => {
-      if (!route.match.domains) return false;
-      
-      const domains = Array.isArray(route.match.domains) 
-        ? route.match.domains 
-        : [route.match.domains];
-      
-      return domains.includes(domain);
-    });
-    
-    // Remove them from the patterns map
-    for (const route of routesToRemove) {
-      this.pathPatterns.delete(route);
-    }
-    
-    // Filter them out of the routes array
-    this.routes = this.routes.filter(route => {
-      if (!route.match.domains) return true;
-      
-      const domains = Array.isArray(route.match.domains) 
-        ? route.match.domains 
-        : [route.match.domains];
-      
-      return !domains.includes(domain);
-    });
-    
-    return this.routes.length !== initialCount;
-  }
-  
-  /**
-   * Legacy method for compatibility with ProxyRouter
-   * Converts IReverseProxyConfig to IRouteConfig and calls setRoutes
-   * 
-   * @param configs Array of legacy proxy configurations
-   */
-  public setNewProxyConfigs(configs: any[]): void {
-    // Convert legacy configs to routes and add them
-    const routes: IRouteConfig[] = configs.map(config => {
-      // Create a basic route configuration from the legacy config
-      return {
-        match: {
-          ports: config.destinationPorts[0], // Just use the first port
-          domains: config.hostName
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: config.destinationIps,
-            port: config.destinationPorts[0]
-          },
-          tls: {
-            mode: 'terminate',
-            certificate: {
-              key: config.privateKey,
-              cert: config.publicKey
-            }
-          }
-        },
-        name: `Legacy Config - ${config.hostName}`,
-        enabled: true
-      };
-    });
-    
-    this.setRoutes(routes);
-  }
-}