fix(routing): unify route based architecture

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

@@ -14,9 +14,11 @@
  * - Static file server routes (createStaticFileRoute)
  * - API routes (createApiRoute)
  * - WebSocket routes (createWebSocketRoute)
+ * - Port mapping routes (createPortMappingRoute, createOffsetPortMappingRoute)
+ * - Dynamic routing (createDynamicRoute, createSmartLoadBalancer)
  */
 
-import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget, TPortRange } from '../models/route-types.js';
+import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget, TPortRange, IRouteContext } from '../models/route-types.js';
 
 /**
  * Create an HTTP-only route configuration
@@ -452,4 +454,168 @@ export function createWebSocketRoute(
     priority: options.priority || 100, // Higher priority for WebSocket routes
     ...options
   };
+}
+
+/**
+ * Create a helper function that applies a port offset
+ * @param offset The offset to apply to the matched port
+ * @returns A function that adds the offset to the matched port
+ */
+export function createPortOffset(offset: number): (context: IRouteContext) => number {
+  return (context: IRouteContext) => context.port + offset;
+}
+
+/**
+ * Create a port mapping route with context-based port function
+ * @param options Port mapping route options
+ * @returns Route configuration object
+ */
+export function createPortMappingRoute(options: {
+  sourcePortRange: TPortRange;
+  targetHost: string | string[] | ((context: IRouteContext) => string | string[]);
+  portMapper: (context: IRouteContext) => number;
+  name?: string;
+  domains?: string | string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.sourcePortRange,
+    domains: options.domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    target: {
+      host: options.targetHost,
+      port: options.portMapper
+    }
+  };
+
+  // Create the route config
+  return {
+    match,
+    action,
+    name: options.name || `Port Mapping Route for ${options.domains || 'all domains'}`,
+    priority: options.priority,
+    ...options
+  };
+}
+
+/**
+ * Create a simple offset port mapping route
+ * @param options Offset port mapping route options
+ * @returns Route configuration object
+ */
+export function createOffsetPortMappingRoute(options: {
+  ports: TPortRange;
+  targetHost: string | string[];
+  offset: number;
+  name?: string;
+  domains?: string | string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  return createPortMappingRoute({
+    sourcePortRange: options.ports,
+    targetHost: options.targetHost,
+    portMapper: (context) => context.port + options.offset,
+    name: options.name || `Offset Mapping (${options.offset > 0 ? '+' : ''}${options.offset}) for ${options.domains || 'all domains'}`,
+    domains: options.domains,
+    priority: options.priority,
+    ...options
+  });
+}
+
+/**
+ * Create a dynamic route with context-based host and port mapping
+ * @param options Dynamic route options
+ * @returns Route configuration object
+ */
+export function createDynamicRoute(options: {
+  ports: TPortRange;
+  targetHost: (context: IRouteContext) => string | string[];
+  portMapper: (context: IRouteContext) => number;
+  name?: string;
+  domains?: string | string[];
+  path?: string;
+  clientIp?: string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.ports,
+    domains: options.domains,
+    path: options.path,
+    clientIp: options.clientIp
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    target: {
+      host: options.targetHost,
+      port: options.portMapper
+    }
+  };
+
+  // Create the route config
+  return {
+    match,
+    action,
+    name: options.name || `Dynamic Route for ${options.domains || 'all domains'}`,
+    priority: options.priority,
+    ...options
+  };
+}
+
+/**
+ * Create a smart load balancer with dynamic domain-based backend selection
+ * @param options Smart load balancer options
+ * @returns Route configuration object
+ */
+export function createSmartLoadBalancer(options: {
+  ports: TPortRange;
+  domainTargets: Record<string, string | string[]>;
+  portMapper: (context: IRouteContext) => number;
+  name?: string;
+  defaultTarget?: string | string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  // Extract all domain keys to create the match criteria
+  const domains = Object.keys(options.domainTargets);
+
+  // Create the smart host selector function
+  const hostSelector = (context: IRouteContext) => {
+    const domain = context.domain || '';
+    return options.domainTargets[domain] || options.defaultTarget || 'localhost';
+  };
+
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.ports,
+    domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    target: {
+      host: hostSelector,
+      port: options.portMapper
+    }
+  };
+
+  // Create the route config
+  return {
+    match,
+    action,
+    name: options.name || `Smart Load Balancer for ${domains.join(', ')}`,
+    priority: options.priority,
+    ...options
+  };
 }

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

@@ -9,14 +9,24 @@ import type { IRouteConfig, IRouteMatch, IRouteAction, TPortRange } from '../mod
 
 /**
  * Validates a port range or port number
- * @param port Port number or port range
+ * @param port Port number, port range, or port function
  * @returns True if valid, false otherwise
  */
-export function isValidPort(port: TPortRange): boolean {
+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);
+    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;
 }
@@ -100,11 +110,20 @@ export function validateRouteAction(action: IRouteAction): { valid: boolean; err
       // 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 || !isValidPort(action.target.port)) {
-        errors.push('Valid target port is required');
+      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');
       }
     }