@push.rocks/smartproxy 15.0.2 → 16.0.3

package/ts/proxies/smart-proxy/utils/route-utils.ts

@@ -0,0 +1,330 @@
+/**
+ * Route Utilities
+ * 
+ * This file provides utility functions for working with route configurations,
+ * including merging, finding, and managing route collections.
+ */
+
+import type { IRouteConfig, IRouteMatch } from '../models/route-types.js';
+import { validateRouteConfig } from './route-validators.js';
+
+/**
+ * Merge two route configurations
+ * The second route's properties will override the first route's properties where they exist
+ * @param baseRoute The base route configuration
+ * @param overrideRoute The route configuration with overriding properties
+ * @returns A new merged route configuration
+ */
+export function mergeRouteConfigs(
+  baseRoute: IRouteConfig,
+  overrideRoute: Partial<IRouteConfig>
+): IRouteConfig {
+  // Create deep copies to avoid modifying original objects
+  const mergedRoute: IRouteConfig = JSON.parse(JSON.stringify(baseRoute));
+
+  // Apply overrides at the top level
+  if (overrideRoute.id) mergedRoute.id = overrideRoute.id;
+  if (overrideRoute.name) mergedRoute.name = overrideRoute.name;
+  if (overrideRoute.enabled !== undefined) mergedRoute.enabled = overrideRoute.enabled;
+  if (overrideRoute.priority !== undefined) mergedRoute.priority = overrideRoute.priority;
+
+  // Merge match configuration
+  if (overrideRoute.match) {
+    mergedRoute.match = { ...mergedRoute.match };
+    
+    if (overrideRoute.match.ports !== undefined) {
+      mergedRoute.match.ports = overrideRoute.match.ports;
+    }
+    
+    if (overrideRoute.match.domains !== undefined) {
+      mergedRoute.match.domains = overrideRoute.match.domains;
+    }
+    
+    if (overrideRoute.match.path !== undefined) {
+      mergedRoute.match.path = overrideRoute.match.path;
+    }
+    
+    if (overrideRoute.match.headers !== undefined) {
+      mergedRoute.match.headers = overrideRoute.match.headers;
+    }
+  }
+
+  // Merge action configuration
+  if (overrideRoute.action) {
+    // If action types are different, replace the entire action
+    if (overrideRoute.action.type && overrideRoute.action.type !== mergedRoute.action.type) {
+      mergedRoute.action = JSON.parse(JSON.stringify(overrideRoute.action));
+    } else {
+      // Otherwise merge the action properties
+      mergedRoute.action = { ...mergedRoute.action };
+      
+      // Merge target
+      if (overrideRoute.action.target) {
+        mergedRoute.action.target = {
+          ...mergedRoute.action.target,
+          ...overrideRoute.action.target
+        };
+      }
+      
+      // Merge TLS options
+      if (overrideRoute.action.tls) {
+        mergedRoute.action.tls = {
+          ...mergedRoute.action.tls,
+          ...overrideRoute.action.tls
+        };
+      }
+      
+      // Merge redirect options
+      if (overrideRoute.action.redirect) {
+        mergedRoute.action.redirect = {
+          ...mergedRoute.action.redirect,
+          ...overrideRoute.action.redirect
+        };
+      }
+      
+      // Merge static options
+      if (overrideRoute.action.static) {
+        mergedRoute.action.static = {
+          ...mergedRoute.action.static,
+          ...overrideRoute.action.static
+        };
+      }
+    }
+  }
+
+  return mergedRoute;
+}
+
+/**
+ * Check if a route matches a domain
+ * @param route The route to check
+ * @param domain The domain to match against
+ * @returns True if the route matches the domain, false otherwise
+ */
+export function routeMatchesDomain(route: IRouteConfig, domain: string): boolean {
+  if (!route.match?.domains) {
+    return false;
+  }
+  
+  const domains = Array.isArray(route.match.domains) 
+    ? route.match.domains 
+    : [route.match.domains];
+  
+  return domains.some(d => {
+    // Handle wildcard domains
+    if (d.startsWith('*.')) {
+      const suffix = d.substring(2);
+      return domain.endsWith(suffix) && domain.split('.').length > suffix.split('.').length;
+    }
+    return d.toLowerCase() === domain.toLowerCase();
+  });
+}
+
+/**
+ * Check if a route matches a port
+ * @param route The route to check
+ * @param port The port to match against
+ * @returns True if the route matches the port, false otherwise
+ */
+export function routeMatchesPort(route: IRouteConfig, port: number): boolean {
+  if (!route.match?.ports) {
+    return false;
+  }
+
+  if (typeof route.match.ports === 'number') {
+    return route.match.ports === port;
+  }
+
+  if (Array.isArray(route.match.ports)) {
+    // Simple case - array of numbers
+    if (typeof route.match.ports[0] === 'number') {
+      return (route.match.ports as number[]).includes(port);
+    }
+
+    // Complex case - array of port ranges
+    if (typeof route.match.ports[0] === 'object') {
+      return (route.match.ports as Array<{ from: number; to: number }>).some(
+        range => port >= range.from && port <= range.to
+      );
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if a route matches a path
+ * @param route The route to check
+ * @param path The path to match against
+ * @returns True if the route matches the path, false otherwise
+ */
+export function routeMatchesPath(route: IRouteConfig, path: string): boolean {
+  if (!route.match?.path) {
+    return true; // No path specified means it matches any path
+  }
+  
+  // Handle exact path
+  if (route.match.path === path) {
+    return true;
+  }
+  
+  // Handle path prefix with trailing slash (e.g., /api/)
+  if (route.match.path.endsWith('/') && path.startsWith(route.match.path)) {
+    return true;
+  }
+  
+  // Handle exact path match without trailing slash
+  if (!route.match.path.endsWith('/') && path === route.match.path) {
+    return true;
+  }
+  
+  // Handle wildcard paths (e.g., /api/*)
+  if (route.match.path.endsWith('*')) {
+    const prefix = route.match.path.slice(0, -1);
+    return path.startsWith(prefix);
+  }
+  
+  return false;
+}
+
+/**
+ * Check if a route matches headers
+ * @param route The route to check
+ * @param headers The headers to match against
+ * @returns True if the route matches the headers, false otherwise
+ */
+export function routeMatchesHeaders(
+  route: IRouteConfig, 
+  headers: Record<string, string>
+): boolean {
+  if (!route.match?.headers || Object.keys(route.match.headers).length === 0) {
+    return true; // No headers specified means it matches any headers
+  }
+  
+  // Check each header in the route's match criteria
+  return Object.entries(route.match.headers).every(([key, value]) => {
+    // If the header isn't present in the request, it doesn't match
+    if (!headers[key]) {
+      return false;
+    }
+    
+    // Handle exact match
+    if (typeof value === 'string') {
+      return headers[key] === value;
+    }
+    
+    // Handle regex match
+    if (value instanceof RegExp) {
+      return value.test(headers[key]);
+    }
+    
+    return false;
+  });
+}
+
+/**
+ * Find all routes that match the given criteria
+ * @param routes Array of routes to search
+ * @param criteria Matching criteria
+ * @returns Array of matching routes sorted by priority
+ */
+export function findMatchingRoutes(
+  routes: IRouteConfig[],
+  criteria: {
+    domain?: string;
+    port?: number;
+    path?: string;
+    headers?: Record<string, string>;
+  }
+): IRouteConfig[] {
+  // Filter routes that are enabled and match all provided criteria
+  const matchingRoutes = routes.filter(route => {
+    // Skip disabled routes
+    if (route.enabled === false) {
+      return false;
+    }
+    
+    // Check domain match if specified
+    if (criteria.domain && !routeMatchesDomain(route, criteria.domain)) {
+      return false;
+    }
+    
+    // Check port match if specified
+    if (criteria.port !== undefined && !routeMatchesPort(route, criteria.port)) {
+      return false;
+    }
+    
+    // Check path match if specified
+    if (criteria.path && !routeMatchesPath(route, criteria.path)) {
+      return false;
+    }
+    
+    // Check headers match if specified
+    if (criteria.headers && !routeMatchesHeaders(route, criteria.headers)) {
+      return false;
+    }
+    
+    return true;
+  });
+  
+  // Sort matching routes by priority (higher priority first)
+  return matchingRoutes.sort((a, b) => {
+    const priorityA = a.priority || 0;
+    const priorityB = b.priority || 0;
+    return priorityB - priorityA; // Higher priority first
+  });
+}
+
+/**
+ * Find the best matching route for the given criteria
+ * @param routes Array of routes to search
+ * @param criteria Matching criteria
+ * @returns The best matching route or undefined if no match
+ */
+export function findBestMatchingRoute(
+  routes: IRouteConfig[],
+  criteria: {
+    domain?: string;
+    port?: number;
+    path?: string;
+    headers?: Record<string, string>;
+  }
+): IRouteConfig | undefined {
+  const matchingRoutes = findMatchingRoutes(routes, criteria);
+  return matchingRoutes.length > 0 ? matchingRoutes[0] : undefined;
+}
+
+/**
+ * Create a route ID based on route properties
+ * @param route Route configuration
+ * @returns Generated route ID
+ */
+export function generateRouteId(route: IRouteConfig): string {
+  // Create a deterministic ID based on route properties
+  const domains = Array.isArray(route.match?.domains) 
+    ? route.match.domains.join('-') 
+    : route.match?.domains || 'any';
+    
+  let portsStr = 'any';
+  if (route.match?.ports) {
+    if (Array.isArray(route.match.ports)) {
+      portsStr = route.match.ports.join('-');
+    } else if (typeof route.match.ports === 'number') {
+      portsStr = route.match.ports.toString();
+    }
+  }
+    
+  const path = route.match?.path || 'any';
+  const action = route.action?.type || 'unknown';
+  
+  return `route-${domains}-${portsStr}-${path}-${action}`.replace(/[^a-zA-Z0-9-]/g, '-');
+}
+
+/**
+ * Clone a route configuration
+ * @param route Route to clone
+ * @returns Deep copy of the route
+ */
+export function cloneRoute(route: IRouteConfig): IRouteConfig {
+  return JSON.parse(JSON.stringify(route));
+}

package/ts/proxies/smart-proxy/utils/route-validators.ts

@@ -0,0 +1,288 @@
+/**
+ * Route Validators
+ * 
+ * This file provides utility functions for validating route configurations.
+ * These validators help ensure that route configurations are valid and correctly structured.
+ */
+
+import type { IRouteConfig, IRouteMatch, IRouteAction, TPortRange } from '../models/route-types.js';
+
+/**
+ * Validates a port range or port number
+ * @param port Port number, port range, or port function
+ * @returns True if valid, false otherwise
+ */
+export function isValidPort(port: any): boolean {
+  if (typeof port === 'number') {
+    return port > 0 && port < 65536; // Valid port range is 1-65535
+  } else if (Array.isArray(port)) {
+    return port.every(p =>
+      (typeof p === 'number' && p > 0 && p < 65536) ||
+      (typeof p === 'object' && 'from' in p && 'to' in p &&
+       p.from > 0 && p.from < 65536 && p.to > 0 && p.to < 65536)
+    );
+  } else if (typeof port === 'function') {
+    // For function-based ports, we can't validate the result at config time
+    // so we just check that it's a function
+    return true;
+  } else if (typeof port === 'object' && 'from' in port && 'to' in port) {
+    return port.from > 0 && port.from < 65536 && port.to > 0 && port.to < 65536;
+  }
+  return false;
+}
+
+/**
+ * Validates a domain string
+ * @param domain Domain string to validate
+ * @returns True if valid, false otherwise
+ */
+export function isValidDomain(domain: string): boolean {
+  // Basic domain validation regex - allows wildcards (*.example.com)
+  const domainRegex = /^(\*\.)?([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+  return domainRegex.test(domain);
+}
+
+/**
+ * Validates a route match configuration
+ * @param match Route match configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteMatch(match: IRouteMatch): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Validate ports
+  if (match.ports !== undefined) {
+    if (!isValidPort(match.ports)) {
+      errors.push('Invalid port number or port range in match.ports');
+    }
+  }
+
+  // Validate domains
+  if (match.domains !== undefined) {
+    if (typeof match.domains === 'string') {
+      if (!isValidDomain(match.domains)) {
+        errors.push(`Invalid domain format: ${match.domains}`);
+      }
+    } else if (Array.isArray(match.domains)) {
+      for (const domain of match.domains) {
+        if (!isValidDomain(domain)) {
+          errors.push(`Invalid domain format: ${domain}`);
+        }
+      }
+    } else {
+      errors.push('Domains must be a string or an array of strings');
+    }
+  }
+
+  // Validate path
+  if (match.path !== undefined) {
+    if (typeof match.path !== 'string' || !match.path.startsWith('/')) {
+      errors.push('Path must be a string starting with /');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Validates a route action configuration
+ * @param action Route action configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteAction(action: IRouteAction): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Validate action type
+  if (!action.type) {
+    errors.push('Action type is required');
+  } else if (!['forward', 'redirect', 'static', 'block'].includes(action.type)) {
+    errors.push(`Invalid action type: ${action.type}`);
+  }
+
+  // Validate target for 'forward' action
+  if (action.type === 'forward') {
+    if (!action.target) {
+      errors.push('Target is required for forward action');
+    } else {
+      // Validate target host
+      if (!action.target.host) {
+        errors.push('Target host is required');
+      } else if (typeof action.target.host !== 'string' &&
+                !Array.isArray(action.target.host) &&
+                typeof action.target.host !== 'function') {
+        errors.push('Target host must be a string, array of strings, or function');
+      }
+
+      // Validate target port
+      if (action.target.port === undefined) {
+        errors.push('Target port is required');
+      } else if (typeof action.target.port !== 'number' &&
+                typeof action.target.port !== 'function') {
+        errors.push('Target port must be a number or a function');
+      } else if (typeof action.target.port === 'number' && !isValidPort(action.target.port)) {
+        errors.push('Target port must be between 1 and 65535');
+      }
+    }
+
+    // Validate TLS options for forward actions
+    if (action.tls) {
+      if (!['passthrough', 'terminate', 'terminate-and-reencrypt'].includes(action.tls.mode)) {
+        errors.push(`Invalid TLS mode: ${action.tls.mode}`);
+      }
+
+      // For termination modes, validate certificate
+      if (['terminate', 'terminate-and-reencrypt'].includes(action.tls.mode)) {
+        if (action.tls.certificate !== 'auto' && 
+            (!action.tls.certificate || !action.tls.certificate.key || !action.tls.certificate.cert)) {
+          errors.push('Certificate must be "auto" or an object with key and cert properties');
+        }
+      }
+    }
+  }
+
+  // Validate redirect for 'redirect' action
+  if (action.type === 'redirect') {
+    if (!action.redirect) {
+      errors.push('Redirect configuration is required for redirect action');
+    } else {
+      if (!action.redirect.to) {
+        errors.push('Redirect target (to) is required');
+      }
+
+      if (action.redirect.status && 
+          ![301, 302, 303, 307, 308].includes(action.redirect.status)) {
+        errors.push('Invalid redirect status code');
+      }
+    }
+  }
+
+  // Validate static file config for 'static' action
+  if (action.type === 'static') {
+    if (!action.static) {
+      errors.push('Static file configuration is required for static action');
+    } else {
+      if (!action.static.root) {
+        errors.push('Static file root directory is required');
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Validates a complete route configuration
+ * @param route Route configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteConfig(route: IRouteConfig): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Check for required properties
+  if (!route.match) {
+    errors.push('Route match configuration is required');
+  }
+
+  if (!route.action) {
+    errors.push('Route action configuration is required');
+  }
+
+  // Validate match configuration
+  if (route.match) {
+    const matchValidation = validateRouteMatch(route.match);
+    if (!matchValidation.valid) {
+      errors.push(...matchValidation.errors.map(err => `Match: ${err}`));
+    }
+  }
+
+  // Validate action configuration
+  if (route.action) {
+    const actionValidation = validateRouteAction(route.action);
+    if (!actionValidation.valid) {
+      errors.push(...actionValidation.errors.map(err => `Action: ${err}`));
+    }
+  }
+
+  // Ensure the route has a unique identifier
+  if (!route.id && !route.name) {
+    errors.push('Route should have either an id or a name for identification');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Validate an array of route configurations
+ * @param routes Array of route configurations to validate
+ * @returns { valid: boolean, errors: { index: number, errors: string[] }[] } Validation result
+ */
+export function validateRoutes(routes: IRouteConfig[]): { 
+  valid: boolean; 
+  errors: { index: number; errors: string[] }[] 
+} {
+  const results: { index: number; errors: string[] }[] = [];
+
+  routes.forEach((route, index) => {
+    const validation = validateRouteConfig(route);
+    if (!validation.valid) {
+      results.push({
+        index,
+        errors: validation.errors
+      });
+    }
+  });
+
+  return {
+    valid: results.length === 0,
+    errors: results
+  };
+}
+
+/**
+ * Check if a route configuration has the required properties for a specific action type
+ * @param route Route configuration to check
+ * @param actionType Expected action type
+ * @returns True if the route has the necessary properties, false otherwise
+ */
+export function hasRequiredPropertiesForAction(route: IRouteConfig, actionType: string): boolean {
+  if (!route.action || route.action.type !== actionType) {
+    return false;
+  }
+
+  switch (actionType) {
+    case 'forward':
+      return !!route.action.target && !!route.action.target.host && !!route.action.target.port;
+    case 'redirect':
+      return !!route.action.redirect && !!route.action.redirect.to;
+    case 'static':
+      return !!route.action.static && !!route.action.static.root;
+    case 'block':
+      return true; // Block action doesn't require additional properties
+    default:
+      return false;
+  }
+}
+
+/**
+ * Throws an error if the route config is invalid, returns the config if valid
+ * Useful for immediate validation when creating routes
+ * @param route Route configuration to validate
+ * @returns The validated route configuration
+ * @throws Error if the route configuration is invalid
+ */
+export function assertValidRoute(route: IRouteConfig): IRouteConfig {
+  const validation = validateRouteConfig(route);
+  if (!validation.valid) {
+    throw new Error(`Invalid route configuration: ${validation.errors.join(', ')}`);
+  }
+  return route;
+}

package/ts/forwarding/config/domain-config.ts

@@ -1,28 +0,0 @@
-import type { IForwardConfig } from './forwarding-types.js';
-
-/**
- * Domain configuration with unified forwarding configuration
- */
-export interface IDomainConfig {
-  // Core properties - domain patterns
-  domains: string[];
-
-  // Unified forwarding configuration
-  forwarding: IForwardConfig;
-}
-
-/**
- * Helper function to create a domain configuration
- */
-export function createDomainConfig(
-  domains: string | string[],
-  forwarding: IForwardConfig
-): IDomainConfig {
-  // Normalize domains to an array
-  const domainArray = Array.isArray(domains) ? domains : [domains];
-
-  return {
-    domains: domainArray,
-    forwarding
-  };
-}