@push.rocks/smartproxy 19.5.19 → 19.5.20

package/ts/routing/router/proxy-router.ts

@@ -1,437 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IReverseProxyConfig } from '../../proxies/http-proxy/models/types.js';
-
-/**
- * Optional path pattern configuration that can be added to proxy configs
- */
-export interface PathPatternConfig {
-  pathPattern?: string;
-}
-
-// Backward compatibility
-export type IPathPatternConfig = PathPatternConfig;
-
-/**
- * Interface for router result with additional metadata
- */
-export interface RouterResult {
-  config: IReverseProxyConfig;
-  pathMatch?: string;
-  pathParams?: Record<string, string>;
-  pathRemainder?: string;
-}
-
-// Backward compatibility
-export type IRouterResult = RouterResult;
-
-/**
- * Router for HTTP reverse proxy requests
- * 
- * 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 ProxyRouter {
-  // Store original configs for reference
-  private reverseProxyConfigs: IReverseProxyConfig[] = [];
-  // Default config to use when no match is found (optional)
-  private defaultConfig?: IReverseProxyConfig;
-  // Store path patterns separately since they're not in the original interface
-  private pathPatterns: Map<IReverseProxyConfig, string> = new Map();
-  // Logger interface
-  private logger: {
-    error: (message: string, data?: any) => void;
-    warn: (message: string, data?: any) => void;
-    info: (message: string, data?: any) => void;
-    debug: (message: string, data?: any) => void;
-  };
-
-  constructor(
-    configs?: IReverseProxyConfig[],
-    logger?: {
-      error: (message: string, data?: any) => void;
-      warn: (message: string, data?: any) => void;
-      info: (message: string, data?: any) => void;
-      debug: (message: string, data?: any) => void;
-    }
-  ) {
-    this.logger = logger || console;
-    if (configs) {
-      this.setNewProxyConfigs(configs);
-    }
-  }
-
-  /**
-   * Sets a new set of reverse configs to be routed to
-   * @param reverseCandidatesArg Array of reverse proxy configurations
-   */
-  public setNewProxyConfigs(reverseCandidatesArg: IReverseProxyConfig[]): void {
-    this.reverseProxyConfigs = [...reverseCandidatesArg];
-
-    // Find default config if any (config with "*" as hostname)
-    this.defaultConfig = this.reverseProxyConfigs.find(config => config.hostName === '*');
-
-    this.logger.info(`Router initialized with ${this.reverseProxyConfigs.length} configs (${this.getHostnames().length} unique hosts)`);
-  }
-
-  /**
-   * Routes a request based on hostname and path
-   * @param req The incoming HTTP request
-   * @returns The matching proxy config or undefined if no match found
-   */
-  public routeReq(req: plugins.http.IncomingMessage): IReverseProxyConfig {
-    const result = this.routeReqWithDetails(req);
-    return result ? result.config : undefined;
-  }
-
-  /**
-   * Routes a request with detailed matching information
-   * @param req The incoming HTTP request
-   * @returns Detailed routing result including matched config 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.defaultConfig ? { config: this.defaultConfig } : 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 exactConfig = this.findConfigForHost(hostWithoutPort, urlPath);
-    if (exactConfig) {
-      return exactConfig;
-    }
-    
-    // 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 wildcardConfig = this.findConfigForHost(wildcardDomain, urlPath);
-        if (wildcardConfig) {
-          return wildcardConfig;
-        }
-      }
-      
-      // Try TLD wildcard (example.*)
-      const baseDomain = domainParts.slice(0, -1).join('.');
-      const tldWildcardDomain = `${baseDomain}.*`;
-      const tldWildcardConfig = this.findConfigForHost(tldWildcardDomain, urlPath);
-      if (tldWildcardConfig) {
-        return tldWildcardConfig;
-      }
-
-      // Try complex wildcard patterns
-      const wildcardPatterns = this.findWildcardMatches(hostWithoutPort);
-      for (const pattern of wildcardPatterns) {
-        const wildcardConfig = this.findConfigForHost(pattern, urlPath);
-        if (wildcardConfig) {
-          return wildcardConfig;
-        }
-      }
-    }
-    
-    // Fall back to default config if available
-    if (this.defaultConfig) {
-      this.logger.warn(`No specific config found for host: ${hostWithoutPort}, using default`);
-      return { config: this.defaultConfig };
-    }
-    
-    this.logger.error(`No config 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[] = [];
-    const hostnameParts = hostname.split('.');
-    
-    // Find all configured hostnames that contain wildcards
-    const wildcardConfigs = this.reverseProxyConfigs.filter(
-      config => config.hostName.includes('*')
-    );
-    
-    // Extract unique wildcard patterns
-    const wildcardPatterns = [...new Set(
-      wildcardConfigs.map(config => config.hostName.toLowerCase())
-    )];
-    
-    // For each wildcard pattern, check if it could match the hostname
-    // using simplified regex pattern matching
-    for (const pattern of wildcardPatterns) {
-      // Skip the default wildcard '*'
-      if (pattern === '*') continue;
-      
-      // Skip already checked patterns (*.domain.com and domain.*)
-      if (pattern.startsWith('*.') && pattern.indexOf('*', 2) === -1) continue;
-      if (pattern.endsWith('.*') && pattern.indexOf('*') === pattern.length - 1) continue;
-      
-      // Convert wildcard pattern to regex
-      const regexPattern = pattern
-        .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(pattern);
-      }
-    }
-    
-    return patterns;
-  }
-
-  /**
-   * Find a config for a specific host and path
-   */
-  private findConfigForHost(hostname: string, path: string): RouterResult | undefined {
-    // Find all configs for this hostname
-    const configs = this.reverseProxyConfigs.filter(
-      config => config.hostName.toLowerCase() === hostname.toLowerCase()
-    );
-    
-    if (configs.length === 0) {
-      return undefined;
-    }
-    
-    // First try configs with path patterns
-    const configsWithPaths = configs.filter(config => this.pathPatterns.has(config));
-    
-    // Sort by path pattern specificity - more specific first
-    configsWithPaths.sort((a, b) => {
-      const aPattern = this.pathPatterns.get(a) || '';
-      const bPattern = this.pathPatterns.get(b) || '';
-      
-      // Exact patterns come before wildcard patterns
-      const aHasWildcard = aPattern.includes('*');
-      const bHasWildcard = bPattern.includes('*');
-      
-      if (aHasWildcard && !bHasWildcard) return 1;
-      if (!aHasWildcard && bHasWildcard) return -1;
-      
-      // Longer patterns are considered more specific
-      return bPattern.length - aPattern.length;
-    });
-    
-    // Check each config with path pattern
-    for (const config of configsWithPaths) {
-      const pathPattern = this.pathPatterns.get(config);
-      if (pathPattern) {
-        const pathMatch = this.matchPath(path, pathPattern);
-        if (pathMatch) {
-          return {
-            config,
-            pathMatch: pathMatch.matched,
-            pathParams: pathMatch.params,
-            pathRemainder: pathMatch.remainder
-          };
-        }
-      }
-    }
-    
-    // If no path pattern matched, use the first config without a path pattern
-    const configWithoutPath = configs.find(config => !this.pathPatterns.has(config));
-    if (configWithoutPath) {
-      return { config: configWithoutPath };
-    }
-    
-    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 proxy configurations
-   * @returns Array of all active configurations
-   */
-  public getProxyConfigs(): IReverseProxyConfig[] {
-    return [...this.reverseProxyConfigs];
-  }
-  
-  /**
-   * Gets all hostnames that this router is configured to handle
-   * @returns Array of hostnames
-   */
-  public getHostnames(): string[] {
-    const hostnames = new Set<string>();
-    for (const config of this.reverseProxyConfigs) {
-      if (config.hostName !== '*') {
-        hostnames.add(config.hostName.toLowerCase());
-      }
-    }
-    return Array.from(hostnames);
-  }
-  
-  /**
-   * Adds a single new proxy configuration
-   * @param config The configuration to add
-   * @param pathPattern Optional path pattern for route matching
-   */
-  public addProxyConfig(
-    config: IReverseProxyConfig,
-    pathPattern?: string
-  ): void {
-    this.reverseProxyConfigs.push(config);
-    
-    // Store path pattern if provided
-    if (pathPattern) {
-      this.pathPatterns.set(config, pathPattern);
-    }
-  }
-  
-  /**
-   * Sets a path pattern for an existing config
-   * @param config The existing configuration
-   * @param pathPattern The path pattern to set
-   * @returns Boolean indicating if the config was found and updated
-   */
-  public setPathPattern(
-    config: IReverseProxyConfig,
-    pathPattern: string
-  ): boolean {
-    const exists = this.reverseProxyConfigs.includes(config);
-    if (exists) {
-      this.pathPatterns.set(config, pathPattern);
-      return true;
-    }
-    return false;
-  }
-  
-  /**
-   * Removes a proxy configuration by hostname
-   * @param hostname The hostname to remove
-   * @returns Boolean indicating whether any configs were removed
-   */
-  public removeProxyConfig(hostname: string): boolean {
-    const initialCount = this.reverseProxyConfigs.length;
-    
-    // Find configs to remove
-    const configsToRemove = this.reverseProxyConfigs.filter(
-      config => config.hostName === hostname
-    );
-    
-    // Remove them from the patterns map
-    for (const config of configsToRemove) {
-      this.pathPatterns.delete(config);
-    }
-    
-    // Filter them out of the configs array
-    this.reverseProxyConfigs = this.reverseProxyConfigs.filter(
-      config => config.hostName !== hostname
-    );
-    
-    return this.reverseProxyConfigs.length !== initialCount;
-  }
-}