@push.rocks/smartproxy 28.0.0 → 28.1.0

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

@@ -1,5 +1,6 @@
 import { logger } from '../../../core/utils/logger.js';
 import type { IInboundProxyProtocolPolicy, IRouteConfig, IRouteMatch, IRouteAction, TPortRange, TTransportProtocol } from '../models/route-types.js';
+import { RouteValidationError, type IRouteValidationErrorEntry } from './route-validation-error.js';
 
 /**
  * Validates route configurations for correctness and safety
@@ -323,62 +324,84 @@ export class RouteValidator {
   }
 
   /**
-   * Validate multiple route configurations
+   * Label every route for validation reports: its name, else its id, else `route[<index>]`.
+   * A name or id that several routes share gets `[<index>]` appended, so every label is unique.
    */
-  public static validateRoutes(routes: IRouteConfig[]): { valid: boolean; errors: Map<string, string[]> } {
-    const errorMap = new Map<string, string[]>();
-    let valid = true;
+  public static getRouteLabels(routes: IRouteConfig[]): string[] {
+    const baseLabels = routes.map((route, index) => route.name || route.id || `route[${index}]`);
+    const labelCounts = new Map<string, number>();
+    for (const label of baseLabels) {
+      labelCounts.set(label, (labelCounts.get(label) ?? 0) + 1);
+    }
+    return baseLabels.map((label, index) => (labelCounts.get(label)! > 1 ? `${label}[${index}]` : label));
+  }
+
+  /**
+   * Validate multiple route configurations.
+   *
+   * `entries` lists every invalid route by position and label; `errors` maps the same
+   * labels to the reasons.
+   */
+  public static validateRoutes(routes: IRouteConfig[]): {
+    valid: boolean;
+    errors: Map<string, string[]>;
+    entries: IRouteValidationErrorEntry[];
+  } {
+    const messagesByIndex: string[][] = routes.map(() => []);
 
     // Check for duplicate route names
     const routeNames = new Set<string>();
-    for (const route of routes) {
+    routes.forEach((route, index) => {
       if (route.name && routeNames.has(route.name)) {
-        const existingErrors = errorMap.get(route.name) || [];
-        existingErrors.push('Duplicate route name');
-        errorMap.set(route.name, existingErrors);
-        valid = false;
+        messagesByIndex[index].push('Duplicate route name');
       }
       if (route.name) {
         routeNames.add(route.name);
       }
-    }
+    });
 
     // Validate each route
-    for (const route of routes) {
-      const result = this.validateRoute(route);
-      if (!result.valid) {
-        errorMap.set(route.name || 'unnamed', result.errors);
-        valid = false;
-      }
-    }
+    routes.forEach((route, index) => {
+      messagesByIndex[index].push(...this.validateRoute(route).errors);
+    });
+
+    const labels = this.getRouteLabels(routes);
 
     // Check for conflicting routes
-    const conflicts = this.findRouteConflicts(routes);
-    if (conflicts.length > 0) {
-      for (const conflict of conflicts) {
-        const existingErrors = errorMap.get(conflict.route) || [];
-        existingErrors.push(conflict.message);
-        errorMap.set(conflict.route, existingErrors);
-      }
-      valid = false;
+    for (const conflict of this.findRouteConflicts(routes, labels)) {
+      messagesByIndex[conflict.index].push(conflict.message);
     }
 
-    return { valid, errors: errorMap };
+    const entries: IRouteValidationErrorEntry[] = [];
+    messagesByIndex.forEach((messages, index) => {
+      if (messages.length > 0) {
+        entries.push({ index, route: labels[index], messages });
+      }
+    });
+
+    return {
+      valid: entries.length === 0,
+      errors: new Map(entries.map((entry) => [entry.route, entry.messages])),
+      entries,
+    };
   }
 
   /**
    * Find potential conflicts between routes
    */
-  private static findRouteConflicts(routes: IRouteConfig[]): Array<{ route: string; message: string }> {
-    const conflicts: Array<{ route: string; message: string }> = [];
-    
-    // Group routes by port
-    const portMap = new Map<number, IRouteConfig[]>();
-    
-    for (const route of routes) {
+  private static findRouteConflicts(
+    routes: IRouteConfig[],
+    labels: string[],
+  ): Array<{ index: number; message: string }> {
+    const conflicts: Array<{ index: number; message: string }> = [];
+
+    // Group route indices by port
+    const portMap = new Map<number, number[]>();
+
+    routes.forEach((route, index) => {
       if (route.match?.ports) {
         const ports = Array.isArray(route.match.ports) ? route.match.ports : [route.match.ports];
-        
+
         // Expand port ranges to individual ports
         const expandedPorts: number[] = [];
         for (const port of ports) {
@@ -390,25 +413,25 @@ export class RouteValidator {
             }
           }
         }
-        
+
         for (const port of expandedPorts) {
           const routesOnPort = portMap.get(port) || [];
-          routesOnPort.push(route);
+          routesOnPort.push(index);
           portMap.set(port, routesOnPort);
         }
       }
-    }
+    });
 
     // Check for conflicting catch-all routes on the same port
     for (const [port, routesOnPort] of portMap) {
-      const catchAllRoutes = routesOnPort.filter(r => 
-        this.isCatchAllDomainMatch(r.match) && !this.hasSourceScope(r.match)
+      const catchAllRoutes = routesOnPort.filter((index) =>
+        this.isCatchAllDomainMatch(routes[index].match) && !this.hasSourceScope(routes[index].match)
       );
-      
+
       if (catchAllRoutes.length > 1) {
-        for (const route of catchAllRoutes) {
+        for (const index of catchAllRoutes) {
           conflicts.push({
-            route: route.name || 'unnamed',
+            index,
             message: `Multiple catch-all routes on port ${port}`
           });
         }
@@ -419,9 +442,9 @@ export class RouteValidator {
     // a shorthand for the full port/transport listener policy, so every route
     // sharing that listener must either all omit it or all use an identical one.
     const listenerPolicies = new Map<string, { route: string; fingerprint: string }>();
-    for (const route of routes) {
+    routes.forEach((route, index) => {
       if (!route.match?.ports) {
-        continue;
+        return;
       }
 
       for (const port of this.expandPorts(route.match.ports)) {
@@ -431,18 +454,18 @@ export class RouteValidator {
           const existing = listenerPolicies.get(key);
           if (!existing) {
             listenerPolicies.set(key, {
-              route: route.name || 'unnamed',
+              route: labels[index],
               fingerprint,
             });
           } else if (existing.fingerprint !== fingerprint) {
             conflicts.push({
-              route: route.name || 'unnamed',
+              index,
               message: `Conflicting inbound PROXY protocol policy on ${transport} port ${port} (differs from ${existing.route})`,
             });
           }
         }
       }
-    }
+    });
 
     return conflicts;
   }
@@ -1031,12 +1054,14 @@ export function hasRequiredPropertiesForAction(route: IRouteConfig, actionType:
  * 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
+ * @throws RouteValidationError 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(', ')}`);
+    throw new RouteValidationError('Invalid route configuration', [
+      { index: 0, route: RouteValidator.getRouteLabels([route])[0], messages: validation.errors },
+    ]);
   }
   return route;
 }