@push.rocks/smartproxy 15.0.2 → 16.0.2

package/dist_ts/proxies/smart-proxy/timeout-manager.js

@@ -50,8 +50,8 @@ export class TimeoutManager {
      * Calculate effective max lifetime based on connection type
      */
     getEffectiveMaxLifetime(record) {
-        // Use domain-specific timeout from forwarding.advanced if available
-        const baseTimeout = record.domainConfig?.forwarding?.advanced?.timeout ||
+        // Use route-specific timeout if available from the routeConfig
+        const baseTimeout = record.routeConfig?.action.advanced?.timeout ||
             this.settings.maxConnectionLifetime ||
             86400000; // 24 hours default
         // For immortal keep-alive connections, use an extremely long lifetime
@@ -151,4 +151,4 @@ export class TimeoutManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZW91dC1tYW5hZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvcHJveGllcy9zbWFydC1wcm94eS90aW1lb3V0LW1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBYztJQUN6QixZQUFvQixRQUE0QjtRQUE1QixhQUFRLEdBQVIsUUFBUSxDQUFvQjtJQUFHLENBQUM7SUFFcEQ7O09BRUc7SUFDSSxpQkFBaUIsQ0FBQyxPQUFlO1FBQ3RDLE1BQU0sZ0JBQWdCLEdBQUcsVUFBVSxDQUFDLENBQUMsZ0NBQWdDO1FBQ3JFLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUFFLGdCQUFnQixDQUFDLENBQUM7SUFDekQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksZ0JBQWdCLENBQUMsV0FBbUIsRUFBRSxtQkFBMkIsQ0FBQztRQUN2RSxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDNUQsTUFBTSxTQUFTLEdBQUcsZUFBZSxHQUFHLENBQUMsZ0JBQWdCLEdBQUcsR0FBRyxDQUFDLENBQUM7UUFDN0QsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQzNCLGVBQWUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxTQUFTLEdBQUcsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUN4RSxDQUFDO0lBQ0osQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYyxDQUFDLE1BQXlCO1FBQzdDLE1BQU0sQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWpDLCtCQUErQjtRQUMvQixJQUFJLE1BQU0sQ0FBQyx1QkFBdUIsRUFBRSxDQUFDO1lBQ25DLE1BQU0sQ0FBQyx1QkFBdUIsR0FBRyxLQUFLLENBQUM7UUFDekMsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLDZCQUE2QixDQUFDLE1BQXlCO1FBQzVELElBQUksZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsSUFBSSxRQUFRLENBQUMsQ0FBQyxrQkFBa0I7UUFFdEYscUVBQXFFO1FBQ3JFLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLE9BQU8sTUFBTSxDQUFDLGdCQUFnQixDQUFDO1FBQ2pDLENBQUM7UUFFRCx3REFBd0Q7UUFDeEQsSUFBSSxNQUFNLENBQUMsWUFBWSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDM0UsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyw2QkFBNkIsSUFBSSxDQUFDLENBQUM7WUFDcEUsZ0JBQWdCLEdBQUcsZ0JBQWdCLEdBQUcsVUFBVSxDQUFDO1FBQ25ELENBQUM7UUFFRCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFRDs7T0FFRztJQUNJLHVCQUF1QixDQUFDLE1BQXlCO1FBQ3RELG9FQUFvRTtRQUNwRSxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsWUFBWSxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsT0FBTztZQUNsRCxJQUFJLENBQUMsUUFBUSxDQUFDLHFCQUFxQjtZQUNuQyxRQUFRLENBQUMsQ0FBQyxtQkFBbUI7UUFFakQsc0VBQXNFO1FBQ3RFLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLE9BQU8sTUFBTSxDQUFDLGdCQUFnQixDQUFDO1FBQ2pDLENBQUM7UUFFRCx5RUFBeUU7UUFDekUsSUFBSSxNQUFNLENBQUMsWUFBWSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDM0UsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQzNCLElBQUksQ0FBQyxRQUFRLENBQUMseUJBQXlCLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxpQkFBaUI7YUFDckYsQ0FBQztRQUNKLENBQUM7UUFFRCxpQ0FBaUM7UUFDakMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLHdCQUF3QixFQUFFLENBQUM7WUFDM0MsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDNUMsQ0FBQztRQUVELE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFFRDs7O09BR0c7SUFDSSxzQkFBc0IsQ0FDM0IsTUFBeUIsRUFDekIsU0FBOEQ7UUFFOUQsMkJBQTJCO1FBQzNCLElBQUksTUFBTSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ3hCLFlBQVksQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDcEMsQ0FBQztRQUVELDhCQUE4QjtRQUM5QixNQUFNLGlCQUFpQixHQUFHLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUUvRCxxQkFBcUI7UUFDckIsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtZQUM1Qiw2QkFBNkI7WUFDN0IsU0FBUyxDQUFDLE1BQU0sRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO1FBQzFDLENBQUMsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO1FBRXRCLG1EQUFtRDtRQUNuRCxJQUFJLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNoQixLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDaEIsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVEOzs7T0FHRztJQUNJLGVBQWUsQ0FBQyxNQUF5QjtRQU05QyxzREFBc0Q7UUFDdEQsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLHNCQUFzQixFQUFFLENBQUM7WUFDekMsT0FBTztnQkFDTCxVQUFVLEVBQUUsS0FBSztnQkFDakIsVUFBVSxFQUFFLEtBQUs7Z0JBQ2pCLGNBQWMsRUFBRSxDQUFDO2dCQUNqQixnQkFBZ0IsRUFBRSxDQUFDO2FBQ3BCLENBQUM7UUFDSixDQUFDO1FBRUQsMkNBQTJDO1FBQzNDLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLE9BQU87Z0JBQ0wsVUFBVSxFQUFFLEtBQUs7Z0JBQ2pCLFVBQVUsRUFBRSxLQUFLO2dCQUNqQixjQUFjLEVBQUUsQ0FBQztnQkFDakIsZ0JBQWdCLEVBQUUsQ0FBQzthQUNwQixDQUFDO1FBQ0osQ0FBQztRQUVELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUN2QixNQUFNLGNBQWMsR0FBRyxHQUFHLEdBQUcsTUFBTSxDQUFDLFlBQVksQ0FBQztRQUNqRCxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyw2QkFBNkIsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVwRSxvQkFBb0I7UUFDcEIsTUFBTSxVQUFVLEdBQUcsY0FBYyxHQUFHLGdCQUFnQixDQUFDO1FBRXJELG1EQUFtRDtRQUNuRCxNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsWUFBWTtZQUNuQixVQUFVO1lBQ1YsQ0FBQyxNQUFNLENBQUMsdUJBQXVCLENBQUM7UUFFbkQsT0FBTztZQUNMLFVBQVU7WUFDVixVQUFVO1lBQ1YsY0FBYztZQUNkLGdCQUFnQjtTQUNqQixDQUFDO0lBQ0osQ0FBQztJQUVEOztPQUVHO0lBQ0ksbUJBQW1CLENBQUMsTUFBeUI7UUFDbEQsMkNBQTJDO1FBQzNDLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLHVEQUF1RDtZQUN2RCxNQUFNLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUM5QixJQUFJLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDcEIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDaEMsQ0FBQztZQUNELE9BQU87UUFDVCxDQUFDO1FBRUQsd0JBQXdCO1FBQ3hCLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsSUFBSSxPQUFPLENBQUMsQ0FBQyxDQUFDLGlCQUFpQjtRQUNqRyxNQUFNLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNwQyxJQUFJLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNwQixNQUFNLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUN0QyxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZW91dC1tYW5hZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvcHJveGllcy9zbWFydC1wcm94eS90aW1lb3V0LW1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBYztJQUN6QixZQUFvQixRQUE0QjtRQUE1QixhQUFRLEdBQVIsUUFBUSxDQUFvQjtJQUFHLENBQUM7SUFFcEQ7O09BRUc7SUFDSSxpQkFBaUIsQ0FBQyxPQUFlO1FBQ3RDLE1BQU0sZ0JBQWdCLEdBQUcsVUFBVSxDQUFDLENBQUMsZ0NBQWdDO1FBQ3JFLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUFFLGdCQUFnQixDQUFDLENBQUM7SUFDekQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksZ0JBQWdCLENBQUMsV0FBbUIsRUFBRSxtQkFBMkIsQ0FBQztRQUN2RSxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDNUQsTUFBTSxTQUFTLEdBQUcsZUFBZSxHQUFHLENBQUMsZ0JBQWdCLEdBQUcsR0FBRyxDQUFDLENBQUM7UUFDN0QsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQzNCLGVBQWUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxTQUFTLEdBQUcsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUN4RSxDQUFDO0lBQ0osQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYyxDQUFDLE1BQXlCO1FBQzdDLE1BQU0sQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWpDLCtCQUErQjtRQUMvQixJQUFJLE1BQU0sQ0FBQyx1QkFBdUIsRUFBRSxDQUFDO1lBQ25DLE1BQU0sQ0FBQyx1QkFBdUIsR0FBRyxLQUFLLENBQUM7UUFDekMsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLDZCQUE2QixDQUFDLE1BQXlCO1FBQzVELElBQUksZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsSUFBSSxRQUFRLENBQUMsQ0FBQyxrQkFBa0I7UUFFdEYscUVBQXFFO1FBQ3JFLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLE9BQU8sTUFBTSxDQUFDLGdCQUFnQixDQUFDO1FBQ2pDLENBQUM7UUFFRCx3REFBd0Q7UUFDeEQsSUFBSSxNQUFNLENBQUMsWUFBWSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDM0UsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyw2QkFBNkIsSUFBSSxDQUFDLENBQUM7WUFDcEUsZ0JBQWdCLEdBQUcsZ0JBQWdCLEdBQUcsVUFBVSxDQUFDO1FBQ25ELENBQUM7UUFFRCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFRDs7T0FFRztJQUNJLHVCQUF1QixDQUFDLE1BQXlCO1FBQ3RELCtEQUErRDtRQUMvRCxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsV0FBVyxFQUFFLE1BQU0sQ0FBQyxRQUFRLEVBQUUsT0FBTztZQUM1QyxJQUFJLENBQUMsUUFBUSxDQUFDLHFCQUFxQjtZQUNuQyxRQUFRLENBQUMsQ0FBQyxtQkFBbUI7UUFFakQsc0VBQXNFO1FBQ3RFLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLE9BQU8sTUFBTSxDQUFDLGdCQUFnQixDQUFDO1FBQ2pDLENBQUM7UUFFRCx5RUFBeUU7UUFDekUsSUFBSSxNQUFNLENBQUMsWUFBWSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDM0UsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQzNCLElBQUksQ0FBQyxRQUFRLENBQUMseUJBQXlCLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxpQkFBaUI7YUFDckYsQ0FBQztRQUNKLENBQUM7UUFFRCxpQ0FBaUM7UUFDakMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLHdCQUF3QixFQUFFLENBQUM7WUFDM0MsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDNUMsQ0FBQztRQUVELE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFFRDs7O09BR0c7SUFDSSxzQkFBc0IsQ0FDM0IsTUFBeUIsRUFDekIsU0FBOEQ7UUFFOUQsMkJBQTJCO1FBQzNCLElBQUksTUFBTSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ3hCLFlBQVksQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDcEMsQ0FBQztRQUVELDhCQUE4QjtRQUM5QixNQUFNLGlCQUFpQixHQUFHLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUUvRCxxQkFBcUI7UUFDckIsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtZQUM1Qiw2QkFBNkI7WUFDN0IsU0FBUyxDQUFDLE1BQU0sRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO1FBQzFDLENBQUMsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO1FBRXRCLG1EQUFtRDtRQUNuRCxJQUFJLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNoQixLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDaEIsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVEOzs7T0FHRztJQUNJLGVBQWUsQ0FBQyxNQUF5QjtRQU05QyxzREFBc0Q7UUFDdEQsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLHNCQUFzQixFQUFFLENBQUM7WUFDekMsT0FBTztnQkFDTCxVQUFVLEVBQUUsS0FBSztnQkFDakIsVUFBVSxFQUFFLEtBQUs7Z0JBQ2pCLGNBQWMsRUFBRSxDQUFDO2dCQUNqQixnQkFBZ0IsRUFBRSxDQUFDO2FBQ3BCLENBQUM7UUFDSixDQUFDO1FBRUQsMkNBQTJDO1FBQzNDLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLE9BQU87Z0JBQ0wsVUFBVSxFQUFFLEtBQUs7Z0JBQ2pCLFVBQVUsRUFBRSxLQUFLO2dCQUNqQixjQUFjLEVBQUUsQ0FBQztnQkFDakIsZ0JBQWdCLEVBQUUsQ0FBQzthQUNwQixDQUFDO1FBQ0osQ0FBQztRQUVELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUN2QixNQUFNLGNBQWMsR0FBRyxHQUFHLEdBQUcsTUFBTSxDQUFDLFlBQVksQ0FBQztRQUNqRCxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyw2QkFBNkIsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVwRSxvQkFBb0I7UUFDcEIsTUFBTSxVQUFVLEdBQUcsY0FBYyxHQUFHLGdCQUFnQixDQUFDO1FBRXJELG1EQUFtRDtRQUNuRCxNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsWUFBWTtZQUNuQixVQUFVO1lBQ1YsQ0FBQyxNQUFNLENBQUMsdUJBQXVCLENBQUM7UUFFbkQsT0FBTztZQUNMLFVBQVU7WUFDVixVQUFVO1lBQ1YsY0FBYztZQUNkLGdCQUFnQjtTQUNqQixDQUFDO0lBQ0osQ0FBQztJQUVEOztPQUVHO0lBQ0ksbUJBQW1CLENBQUMsTUFBeUI7UUFDbEQsMkNBQTJDO1FBQzNDLElBQUksTUFBTSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQzNFLHVEQUF1RDtZQUN2RCxNQUFNLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUM5QixJQUFJLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDcEIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDaEMsQ0FBQztZQUNELE9BQU87UUFDVCxDQUFDO1FBRUQsd0JBQXdCO1FBQ3hCLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsSUFBSSxPQUFPLENBQUMsQ0FBQyxDQUFDLGlCQUFpQjtRQUNqRyxNQUFNLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNwQyxJQUFJLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNwQixNQUFNLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUN0QyxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/proxies/smart-proxy/utils/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SmartProxy Route Utilities
+ *
+ * This file exports all route-related utilities for the SmartProxy module,
+ * including helpers, validators, utilities, and patterns for working with routes.
+ */
+export * from './route-helpers.js';
+export * from './route-validators.js';
+export * from './route-utils.js';
+import { createWebSocketRoute as createWebSocketPatternRoute, createLoadBalancerRoute as createLoadBalancerPatternRoute, createApiGatewayRoute, createStaticFileServerRoute, addRateLimiting, addBasicAuth, addJwtAuth } from './route-patterns.js';
+export { createWebSocketPatternRoute, createLoadBalancerPatternRoute, createApiGatewayRoute, createStaticFileServerRoute, addRateLimiting, addBasicAuth, addJwtAuth };
+export * from './route-migration-utils.js';

package/dist_ts/proxies/smart-proxy/utils/index.js

@@ -0,0 +1,19 @@
+/**
+ * SmartProxy Route Utilities
+ *
+ * This file exports all route-related utilities for the SmartProxy module,
+ * including helpers, validators, utilities, and patterns for working with routes.
+ */
+// Export route helpers for creating routes
+export * from './route-helpers.js';
+// Export route validators for validating route configurations
+export * from './route-validators.js';
+// Export route utilities for route operations
+export * from './route-utils.js';
+// Export route patterns with renamed exports to avoid conflicts
+import { createWebSocketRoute as createWebSocketPatternRoute, createLoadBalancerRoute as createLoadBalancerPatternRoute, createApiGatewayRoute, createStaticFileServerRoute, addRateLimiting, addBasicAuth, addJwtAuth } from './route-patterns.js';
+export { createWebSocketPatternRoute, createLoadBalancerPatternRoute, createApiGatewayRoute, createStaticFileServerRoute, addRateLimiting, addBasicAuth, addJwtAuth };
+// Export migration utilities for transitioning from domain-based to route-based configs
+// Note: These will be removed in a future version once migration is complete
+export * from './route-migration-utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgsMkNBQTJDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsOERBQThEO0FBQzlELGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsOENBQThDO0FBQzlDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsZ0VBQWdFO0FBQ2hFLE9BQU8sRUFDTCxvQkFBb0IsSUFBSSwyQkFBMkIsRUFDbkQsdUJBQXVCLElBQUksOEJBQThCLEVBQ3pELHFCQUFxQixFQUNyQiwyQkFBMkIsRUFDM0IsZUFBZSxFQUNmLFlBQVksRUFDWixVQUFVLEVBQ1gsTUFBTSxxQkFBcUIsQ0FBQztBQUU3QixPQUFPLEVBQ0wsMkJBQTJCLEVBQzNCLDhCQUE4QixFQUM5QixxQkFBcUIsRUFDckIsMkJBQTJCLEVBQzNCLGVBQWUsRUFDZixZQUFZLEVBQ1osVUFBVSxFQUNYLENBQUM7QUFFRix3RkFBd0Y7QUFDeEYsNkVBQTZFO0FBQzdFLGNBQWMsNEJBQTRCLENBQUMifQ==

package/dist_ts/proxies/smart-proxy/utils/route-helpers.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Route Helper Functions
+ *
+ * This file provides utility functions for creating route configurations for common scenarios.
+ * These functions aim to simplify the creation of route configurations for typical use cases.
+ *
+ * This module includes helper functions for creating:
+ * - HTTP routes (createHttpRoute)
+ * - HTTPS routes with TLS termination (createHttpsTerminateRoute)
+ * - HTTP to HTTPS redirects (createHttpToHttpsRedirect)
+ * - HTTPS passthrough routes (createHttpsPassthroughRoute)
+ * - Complete HTTPS servers with redirects (createCompleteHttpsServer)
+ * - Load balancer routes (createLoadBalancerRoute)
+ * - Static file server routes (createStaticFileRoute)
+ * - API routes (createApiRoute)
+ * - WebSocket routes (createWebSocketRoute)
+ */
+import type { IRouteConfig } from '../models/route-types.js';
+/**
+ * Create an HTTP-only route configuration
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create an HTTPS route with TLS termination (including HTTP redirect to HTTPS)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpsTerminateRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    reencrypt?: boolean;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create an HTTP to HTTPS redirect route
+ * @param domains Domain(s) to match
+ * @param httpsPort HTTPS port to redirect to (default: 443)
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpToHttpsRedirect(domains: string | string[], httpsPort?: number, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create an HTTPS passthrough route (SNI-based forwarding without TLS termination)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpsPassthroughRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create a complete HTTPS server with HTTP to HTTPS redirects
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional configuration options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export declare function createCompleteHttpsServer(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    reencrypt?: boolean;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig[];
+/**
+ * Create a load balancer route (round-robin between multiple backend hosts)
+ * @param domains Domain(s) to match
+ * @param hosts Array of backend hosts to load balance between
+ * @param port Backend port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createLoadBalancerRoute(domains: string | string[], hosts: string[], port: number, options?: {
+    tls?: {
+        mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+        certificate?: 'auto' | {
+            key: string;
+            cert: string;
+        };
+    };
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a static file server route
+ * @param domains Domain(s) to match
+ * @param rootDir Root directory path for static files
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createStaticFileRoute(domains: string | string[], rootDir: string, options?: {
+    indexFiles?: string[];
+    serveOnHttps?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create an API route configuration
+ * @param domains Domain(s) to match
+ * @param apiPath API base path (e.g., "/api")
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createApiRoute(domains: string | string[], apiPath: string, target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    addCorsHeaders?: boolean;
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a WebSocket route configuration
+ * @param domains Domain(s) to match
+ * @param wsPath WebSocket path (e.g., "/ws")
+ * @param target Target WebSocket server host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createWebSocketRoute(domains: string | string[], wsPath: string, target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    pingInterval?: number;
+    pingTimeout?: number;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-helpers.js

@@ -0,0 +1,332 @@
+/**
+ * Route Helper Functions
+ *
+ * This file provides utility functions for creating route configurations for common scenarios.
+ * These functions aim to simplify the creation of route configurations for typical use cases.
+ *
+ * This module includes helper functions for creating:
+ * - HTTP routes (createHttpRoute)
+ * - HTTPS routes with TLS termination (createHttpsTerminateRoute)
+ * - HTTP to HTTPS redirects (createHttpToHttpsRedirect)
+ * - HTTPS passthrough routes (createHttpsPassthroughRoute)
+ * - Complete HTTPS servers with redirects (createCompleteHttpsServer)
+ * - Load balancer routes (createLoadBalancerRoute)
+ * - Static file server routes (createStaticFileRoute)
+ * - API routes (createApiRoute)
+ * - WebSocket routes (createWebSocketRoute)
+ */
+/**
+ * Create an HTTP-only route configuration
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 80,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTPS route with TLS termination (including HTTP redirect to HTTPS)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpsTerminateRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.httpsPort || 443,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target,
+        tls: {
+            mode: options.reencrypt ? 'terminate-and-reencrypt' : 'terminate',
+            certificate: options.certificate || 'auto'
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTPS Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTP to HTTPS redirect route
+ * @param domains Domain(s) to match
+ * @param httpsPort HTTPS port to redirect to (default: 443)
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpToHttpsRedirect(domains, httpsPort = 443, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 80,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'redirect',
+        redirect: {
+            to: `https://{domain}:${httpsPort}{path}`,
+            status: 301
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTPS passthrough route (SNI-based forwarding without TLS termination)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpsPassthroughRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 443,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target,
+        tls: {
+            mode: 'passthrough'
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTPS Passthrough for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create a complete HTTPS server with HTTP to HTTPS redirects
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional configuration options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export function createCompleteHttpsServer(domains, target, options = {}) {
+    // Create the HTTPS route
+    const httpsRoute = createHttpsTerminateRoute(domains, target, options);
+    // Create the HTTP redirect route
+    const httpRedirectRoute = createHttpToHttpsRedirect(domains, 
+    // Extract the HTTPS port from the HTTPS route - ensure it's a number
+    typeof options.httpsPort === 'number' ? options.httpsPort :
+        Array.isArray(options.httpsPort) ? options.httpsPort[0] : 443, {
+        // Set the HTTP port
+        match: {
+            ports: options.httpPort || 80,
+            domains
+        },
+        name: `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    });
+    return [httpsRoute, httpRedirectRoute];
+}
+/**
+ * Create a load balancer route (round-robin between multiple backend hosts)
+ * @param domains Domain(s) to match
+ * @param hosts Array of backend hosts to load balance between
+ * @param port Backend port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createLoadBalancerRoute(domains, hosts, port, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || (options.tls ? 443 : 80),
+        domains
+    };
+    // Create route target
+    const target = {
+        host: hosts,
+        port
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target
+    };
+    // Add TLS configuration if provided
+    if (options.tls) {
+        action.tls = {
+            mode: options.tls.mode,
+            certificate: options.tls.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Load Balancer for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create a static file server route
+ * @param domains Domain(s) to match
+ * @param rootDir Root directory path for static files
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createStaticFileRoute(domains, rootDir, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.serveOnHttps
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'static',
+        static: {
+            root: rootDir,
+            index: options.indexFiles || ['index.html', 'index.htm']
+        }
+    };
+    // Add TLS configuration if serving on HTTPS
+    if (options.serveOnHttps) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Static Files for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an API route configuration
+ * @param domains Domain(s) to match
+ * @param apiPath API base path (e.g., "/api")
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createApiRoute(domains, apiPath, target, options = {}) {
+    // Normalize API path
+    const normalizedPath = apiPath.startsWith('/') ? apiPath : `/${apiPath}`;
+    const pathWithWildcard = normalizedPath.endsWith('/')
+        ? `${normalizedPath}*`
+        : `${normalizedPath}/*`;
+    // Create route match
+    const match = {
+        ports: options.useTls
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains,
+        path: pathWithWildcard
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target
+    };
+    // Add TLS configuration if using HTTPS
+    if (options.useTls) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Add CORS headers if requested
+    const headers = {};
+    if (options.addCorsHeaders) {
+        headers.response = {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+            'Access-Control-Max-Age': '86400'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        headers: Object.keys(headers).length > 0 ? headers : undefined,
+        name: options.name || `API Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 100, // Higher priority for specific path matches
+        ...options
+    };
+}
+/**
+ * Create a WebSocket route configuration
+ * @param domains Domain(s) to match
+ * @param wsPath WebSocket path (e.g., "/ws")
+ * @param target Target WebSocket server host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createWebSocketRoute(domains, wsPath, target, options = {}) {
+    // Normalize WebSocket path
+    const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
+    // Create route match
+    const match = {
+        ports: options.useTls
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains,
+        path: normalizedPath
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target,
+        websocket: {
+            enabled: true,
+            pingInterval: options.pingInterval || 30000, // 30 seconds
+            pingTimeout: options.pingTimeout || 5000 // 5 seconds
+        }
+    };
+    // Add TLS configuration if using HTTPS
+    if (options.useTls) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `WebSocket Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 100, // Higher priority for WebSocket routes
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-helpers.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-helpers.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/utils/route-migration-utils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Route Migration Utilities
+ *
+ * This file provides utility functions for migrating from legacy domain-based
+ * configuration to the new route-based configuration system. These functions
+ * are temporary and will be removed after the migration is complete.
+ */
+import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
+import type { IRouteConfig } from '../models/route-types.js';
+/**
+ * Legacy domain config interface (for migration only)
+ * @deprecated This interface will be removed in a future version
+ */
+export interface ILegacyDomainConfig {
+    domains: string[];
+    forwarding: {
+        type: TForwardingType;
+        target: {
+            host: string | string[];
+            port: number;
+        };
+        [key: string]: any;
+    };
+}
+/**
+ * Convert a legacy domain config to a route-based config
+ * @param domainConfig Legacy domain configuration
+ * @param additionalOptions Additional options to add to the route
+ * @returns Route configuration
+ * @deprecated This function will be removed in a future version
+ */
+export declare function domainConfigToRouteConfig(domainConfig: ILegacyDomainConfig, additionalOptions?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Convert an array of legacy domain configs to route configurations
+ * @param domainConfigs Array of legacy domain configurations
+ * @returns Array of route configurations
+ * @deprecated This function will be removed in a future version
+ */
+export declare function domainConfigsToRouteConfigs(domainConfigs: ILegacyDomainConfig[]): IRouteConfig[];
+/**
+ * Extract domains from a route configuration
+ * @param route Route configuration
+ * @returns Array of domains
+ */
+export declare function extractDomainsFromRoute(route: IRouteConfig): string[];
+/**
+ * Extract domains from an array of route configurations
+ * @param routes Array of route configurations
+ * @returns Array of unique domains
+ */
+export declare function extractDomainsFromRoutes(routes: IRouteConfig[]): string[];