feat(routing): Add SharedRouteManager and route matching utilities for enhanced routing capabilities

ts/core/routing/route-utils.ts

@@ -0,0 +1,142 @@
+/**
+ * Route matching utilities for SmartProxy components
+ * 
+ * This file provides utility functions that use the unified matchers
+ * and additional route-specific utilities.
+ */
+
+import { DomainMatcher, PathMatcher, IpMatcher, HeaderMatcher } from '../routing/matchers/index.js';
+import { RouteSpecificity } from '../routing/specificity.js';
+import type { IRouteSpecificity } from '../routing/types.js';
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+
+/**
+ * Match a domain pattern against a domain
+ * @deprecated Use DomainMatcher.match() directly
+ */
+export function matchDomain(pattern: string, domain: string): boolean {
+  return DomainMatcher.match(pattern, domain);
+}
+
+/**
+ * Match domains from a route against a given domain
+ * 
+ * @param domains Array or single domain pattern to match against
+ * @param domain Domain to match
+ * @returns Whether the domain matches any of the patterns
+ */
+export function matchRouteDomain(domains: string | string[] | undefined, domain: string | undefined): boolean {
+  // If no domains specified in the route, match all domains
+  if (!domains) {
+    return true;
+  }
+
+  // If no domain in the request, can't match domain-specific routes
+  if (!domain) {
+    return false;
+  }
+  
+  const patterns = Array.isArray(domains) ? domains : [domains];
+  return patterns.some(pattern => matchDomain(pattern, domain));
+}
+
+/**
+ * Match a path pattern against a path
+ * @deprecated Use PathMatcher.match() directly
+ */
+export function matchPath(pattern: string, path: string): boolean {
+  return PathMatcher.match(pattern, path).matches;
+}
+
+// Helper functions removed - use IpMatcher internal methods instead
+
+/**
+ * Match an IP against a CIDR pattern
+ * @deprecated Use IpMatcher.matchCidr() directly
+ */
+export function matchIpCidr(cidr: string, ip: string): boolean {
+  return IpMatcher.matchCidr(cidr, ip);
+}
+
+/**
+ * Match an IP pattern against an IP
+ * @deprecated Use IpMatcher.match() directly
+ */
+export function matchIpPattern(pattern: string, ip: string): boolean {
+  return IpMatcher.match(pattern, ip);
+}
+
+/**
+ * Match an IP against allowed and blocked IP patterns
+ * @deprecated Use IpMatcher.isAuthorized() directly
+ */
+export function isIpAuthorized(
+  ip: string, 
+  ipAllowList: string[] = ['*'], 
+  ipBlockList: string[] = []
+): boolean {
+  return IpMatcher.isAuthorized(ip, ipAllowList, ipBlockList);
+}
+
+/**
+ * Match an HTTP header pattern against a header value
+ * @deprecated Use HeaderMatcher.match() directly
+ */
+export function matchHeader(pattern: string | RegExp, value: string): boolean {
+  // Convert RegExp to string pattern for HeaderMatcher
+  const stringPattern = pattern instanceof RegExp ? pattern.source : pattern;
+  return HeaderMatcher.match(stringPattern, value, { exactMatch: true });
+}
+
+/**
+ * Calculate route specificity score
+ * Higher score means more specific matching criteria
+ * 
+ * @param match Match criteria to evaluate
+ * @returns Numeric specificity score
+ * @deprecated Consider using RouteSpecificity.calculate() with full IRouteConfig
+ */
+export function calculateRouteSpecificity(match: {
+  domains?: string | string[];
+  path?: string;
+  clientIp?: string[];
+  tlsVersion?: string[];
+  headers?: Record<string, string | RegExp>;
+}): number {
+  let score = 0;
+  
+  // Path specificity using PathMatcher
+  if (match.path) {
+    score += PathMatcher.calculateSpecificity(match.path);
+  }
+  
+  // Domain specificity using DomainMatcher
+  if (match.domains) {
+    const domains = Array.isArray(match.domains) ? match.domains : [match.domains];
+    // Use the highest specificity among all domains
+    const domainScore = Math.max(...domains.map(d => DomainMatcher.calculateSpecificity(d)));
+    score += domainScore;
+  }
+  
+  // Headers specificity using HeaderMatcher
+  if (match.headers) {
+    const stringHeaders: Record<string, string> = {};
+    for (const [key, value] of Object.entries(match.headers)) {
+      stringHeaders[key] = value instanceof RegExp ? value.source : value;
+    }
+    score += HeaderMatcher.calculateSpecificity(stringHeaders);
+  }
+  
+  // Client IP adds some specificity
+  if (match.clientIp && match.clientIp.length > 0) {
+    // Use the first IP pattern for specificity
+    score += IpMatcher.calculateSpecificity(match.clientIp[0]);
+  }
+  
+  // TLS version adds minimal specificity
+  if (match.tlsVersion && match.tlsVersion.length > 0) {
+    score += match.tlsVersion.length * 10;
+  }
+  
+  return score;
+}