@push.rocks/smartproxy 15.0.2 → 16.0.2

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

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+/**
+ * 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 function domainConfigToRouteConfig(domainConfig, additionalOptions = {}) {
+    // Default port based on forwarding type
+    let defaultPort = 80;
+    let tlsMode;
+    switch (domainConfig.forwarding.type) {
+        case 'http-only':
+            defaultPort = 80;
+            break;
+        case 'https-passthrough':
+            defaultPort = 443;
+            tlsMode = 'passthrough';
+            break;
+        case 'https-terminate-to-http':
+            defaultPort = 443;
+            tlsMode = 'terminate';
+            break;
+        case 'https-terminate-to-https':
+            defaultPort = 443;
+            tlsMode = 'terminate-and-reencrypt';
+            break;
+    }
+    // Create route match criteria
+    const match = {
+        ports: additionalOptions.match?.ports || defaultPort,
+        domains: domainConfig.domains
+    };
+    // Create route target
+    const target = {
+        host: domainConfig.forwarding.target.host,
+        port: domainConfig.forwarding.target.port
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target
+    };
+    // Add TLS configuration if needed
+    if (tlsMode) {
+        action.tls = {
+            mode: tlsMode,
+            certificate: 'auto'
+        };
+        // If the legacy config has custom certificates, use them
+        if (domainConfig.forwarding.https?.customCert) {
+            action.tls.certificate = {
+                key: domainConfig.forwarding.https.customCert.key,
+                cert: domainConfig.forwarding.https.customCert.cert
+            };
+        }
+    }
+    // Add security options if present
+    if (domainConfig.forwarding.security) {
+        action.security = domainConfig.forwarding.security;
+    }
+    // Create the route config
+    const routeConfig = {
+        match,
+        action,
+        // Include a name based on domains if not provided
+        name: additionalOptions.name || `Legacy route for ${domainConfig.domains.join(', ')}`,
+        // Include a note that this was converted from a legacy config
+        description: additionalOptions.description || 'Converted from legacy domain configuration'
+    };
+    // Add optional properties if provided
+    if (additionalOptions.priority !== undefined) {
+        routeConfig.priority = additionalOptions.priority;
+    }
+    if (additionalOptions.tags) {
+        routeConfig.tags = additionalOptions.tags;
+    }
+    return routeConfig;
+}
+/**
+ * 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 function domainConfigsToRouteConfigs(domainConfigs) {
+    return domainConfigs.map(config => domainConfigToRouteConfig(config));
+}
+/**
+ * Extract domains from a route configuration
+ * @param route Route configuration
+ * @returns Array of domains
+ */
+export function extractDomainsFromRoute(route) {
+    if (!route.match.domains) {
+        return [];
+    }
+    return Array.isArray(route.match.domains)
+        ? route.match.domains
+        : [route.match.domains];
+}
+/**
+ * Extract domains from an array of route configurations
+ * @param routes Array of route configurations
+ * @returns Array of unique domains
+ */
+export function extractDomainsFromRoutes(routes) {
+    const domains = new Set();
+    for (const route of routes) {
+        const routeDomains = extractDomainsFromRoute(route);
+        for (const domain of routeDomains) {
+            domains.add(domain);
+        }
+    }
+    return Array.from(domains);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,131 @@
+/**
+ * Route Patterns
+ *
+ * This file provides pre-defined route patterns for common use cases.
+ * These patterns can be used as templates for creating route configurations.
+ */
+import type { IRouteConfig } from '../models/route-types.js';
+/**
+ * Create an API Gateway route pattern
+ * @param domains Domain(s) to match
+ * @param apiBasePath Base path for API endpoints (e.g., '/api')
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns API route configuration
+ */
+export declare function createApiGatewayRoute(domains: string | string[], apiBasePath: string, target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    addCorsHeaders?: boolean;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a static file server route pattern
+ * @param domains Domain(s) to match
+ * @param rootDirectory Root directory for static files
+ * @param options Additional route options
+ * @returns Static file server route configuration
+ */
+export declare function createStaticFileServerRoute(domains: string | string[], rootDirectory: string, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    indexFiles?: string[];
+    cacheControl?: string;
+    path?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a WebSocket route pattern
+ * @param domains Domain(s) to match
+ * @param target WebSocket server host and port
+ * @param options Additional route options
+ * @returns WebSocket route configuration
+ */
+export declare function createWebSocketRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    path?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a load balancer route pattern
+ * @param domains Domain(s) to match
+ * @param backends Array of backend servers
+ * @param options Additional route options
+ * @returns Load balancer route configuration
+ */
+export declare function createLoadBalancerRoute(domains: string | string[], backends: Array<{
+    host: string;
+    port: number;
+}>, options?: {
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    algorithm?: 'round-robin' | 'least-connections' | 'ip-hash';
+    healthCheck?: {
+        path: string;
+        interval: number;
+        timeout: number;
+        unhealthyThreshold: number;
+        healthyThreshold: number;
+    };
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a rate limiting route pattern
+ * @param baseRoute Base route to add rate limiting to
+ * @param rateLimit Rate limiting configuration
+ * @returns Route with rate limiting
+ */
+export declare function addRateLimiting(baseRoute: IRouteConfig, rateLimit: {
+    maxRequests: number;
+    window: number;
+    keyBy?: 'ip' | 'path' | 'header';
+    headerName?: string;
+    errorMessage?: string;
+}): IRouteConfig;
+/**
+ * Create a basic authentication route pattern
+ * @param baseRoute Base route to add authentication to
+ * @param auth Authentication configuration
+ * @returns Route with basic authentication
+ */
+export declare function addBasicAuth(baseRoute: IRouteConfig, auth: {
+    users: Array<{
+        username: string;
+        password: string;
+    }>;
+    realm?: string;
+    excludePaths?: string[];
+}): IRouteConfig;
+/**
+ * Create a JWT authentication route pattern
+ * @param baseRoute Base route to add JWT authentication to
+ * @param jwt JWT authentication configuration
+ * @returns Route with JWT authentication
+ */
+export declare function addJwtAuth(baseRoute: IRouteConfig, jwt: {
+    secret: string;
+    algorithm?: string;
+    issuer?: string;
+    audience?: string;
+    expiresIn?: number;
+    excludePaths?: string[];
+}): IRouteConfig;

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

@@ -0,0 +1,217 @@
+/**
+ * Route Patterns
+ *
+ * This file provides pre-defined route patterns for common use cases.
+ * These patterns can be used as templates for creating route configurations.
+ */
+import { createHttpRoute, createHttpsTerminateRoute, createHttpsPassthroughRoute, createCompleteHttpsServer } from './route-helpers.js';
+import { mergeRouteConfigs } from './route-utils.js';
+/**
+ * Create an API Gateway route pattern
+ * @param domains Domain(s) to match
+ * @param apiBasePath Base path for API endpoints (e.g., '/api')
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns API route configuration
+ */
+export function createApiGatewayRoute(domains, apiBasePath, target, options = {}) {
+    // Normalize apiBasePath to ensure it starts with / and doesn't end with /
+    const normalizedPath = apiBasePath.startsWith('/')
+        ? apiBasePath
+        : `/${apiBasePath}`;
+    // Add wildcard to path to match all API endpoints
+    const apiPath = normalizedPath.endsWith('/')
+        ? `${normalizedPath}*`
+        : `${normalizedPath}/*`;
+    // Create base route
+    const baseRoute = options.useTls
+        ? createHttpsTerminateRoute(domains, target, {
+            certificate: options.certificate || 'auto'
+        })
+        : createHttpRoute(domains, target);
+    // Add API-specific configurations
+    const apiRoute = {
+        match: {
+            ...baseRoute.match,
+            path: apiPath
+        },
+        name: options.name || `API Gateway: ${apiPath} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
+        priority: options.priority || 100 // Higher priority for specific path matching
+    };
+    // Add CORS headers if requested
+    if (options.addCorsHeaders) {
+        apiRoute.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'
+            }
+        };
+    }
+    return mergeRouteConfigs(baseRoute, apiRoute);
+}
+/**
+ * Create a static file server route pattern
+ * @param domains Domain(s) to match
+ * @param rootDirectory Root directory for static files
+ * @param options Additional route options
+ * @returns Static file server route configuration
+ */
+export function createStaticFileServerRoute(domains, rootDirectory, options = {}) {
+    // Create base route with static action
+    const baseRoute = {
+        match: {
+            domains,
+            ports: options.useTls ? 443 : 80,
+            path: options.path || '/'
+        },
+        action: {
+            type: 'static',
+            static: {
+                root: rootDirectory,
+                index: options.indexFiles || ['index.html', 'index.htm'],
+                headers: {
+                    'Cache-Control': options.cacheControl || 'public, max-age=3600'
+                }
+            }
+        },
+        name: options.name || `Static Server: ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 50
+    };
+    // Add TLS configuration if requested
+    if (options.useTls) {
+        baseRoute.action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    return baseRoute;
+}
+/**
+ * Create a WebSocket route pattern
+ * @param domains Domain(s) to match
+ * @param target WebSocket server host and port
+ * @param options Additional route options
+ * @returns WebSocket route configuration
+ */
+export function createWebSocketRoute(domains, target, options = {}) {
+    // Create base route
+    const baseRoute = options.useTls
+        ? createHttpsTerminateRoute(domains, target, {
+            certificate: options.certificate || 'auto'
+        })
+        : createHttpRoute(domains, target);
+    // Add WebSocket-specific configurations
+    const wsRoute = {
+        match: {
+            ...baseRoute.match,
+            path: options.path || '/ws',
+            headers: {
+                'Upgrade': 'websocket'
+            }
+        },
+        action: {
+            ...baseRoute.action,
+            websocket: {
+                enabled: true,
+                pingInterval: options.pingInterval || 30000, // 30 seconds
+                pingTimeout: options.pingTimeout || 5000 // 5 seconds
+            }
+        },
+        name: options.name || `WebSocket: ${Array.isArray(domains) ? domains.join(', ') : domains} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
+        priority: options.priority || 100 // Higher priority for WebSocket routes
+    };
+    return mergeRouteConfigs(baseRoute, wsRoute);
+}
+/**
+ * Create a load balancer route pattern
+ * @param domains Domain(s) to match
+ * @param backends Array of backend servers
+ * @param options Additional route options
+ * @returns Load balancer route configuration
+ */
+export function createLoadBalancerRoute(domains, backends, options = {}) {
+    // Extract hosts and ensure all backends use the same port
+    const port = backends[0].port;
+    const hosts = backends.map(backend => backend.host);
+    // Create route with multiple hosts for load balancing
+    const baseRoute = options.useTls
+        ? createHttpsTerminateRoute(domains, { host: hosts, port }, {
+            certificate: options.certificate || 'auto'
+        })
+        : createHttpRoute(domains, { host: hosts, port });
+    // Add load balancing specific configurations
+    const lbRoute = {
+        action: {
+            ...baseRoute.action,
+            loadBalancing: {
+                algorithm: options.algorithm || 'round-robin',
+                healthCheck: options.healthCheck
+            }
+        },
+        name: options.name || `Load Balancer: ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 50
+    };
+    return mergeRouteConfigs(baseRoute, lbRoute);
+}
+/**
+ * Create a rate limiting route pattern
+ * @param baseRoute Base route to add rate limiting to
+ * @param rateLimit Rate limiting configuration
+ * @returns Route with rate limiting
+ */
+export function addRateLimiting(baseRoute, rateLimit) {
+    return mergeRouteConfigs(baseRoute, {
+        security: {
+            rateLimit: {
+                enabled: true,
+                maxRequests: rateLimit.maxRequests,
+                window: rateLimit.window,
+                keyBy: rateLimit.keyBy || 'ip',
+                headerName: rateLimit.headerName,
+                errorMessage: rateLimit.errorMessage || 'Rate limit exceeded. Please try again later.'
+            }
+        }
+    });
+}
+/**
+ * Create a basic authentication route pattern
+ * @param baseRoute Base route to add authentication to
+ * @param auth Authentication configuration
+ * @returns Route with basic authentication
+ */
+export function addBasicAuth(baseRoute, auth) {
+    return mergeRouteConfigs(baseRoute, {
+        security: {
+            basicAuth: {
+                enabled: true,
+                users: auth.users,
+                realm: auth.realm || 'Restricted Area',
+                excludePaths: auth.excludePaths || []
+            }
+        }
+    });
+}
+/**
+ * Create a JWT authentication route pattern
+ * @param baseRoute Base route to add JWT authentication to
+ * @param jwt JWT authentication configuration
+ * @returns Route with JWT authentication
+ */
+export function addJwtAuth(baseRoute, jwt) {
+    return mergeRouteConfigs(baseRoute, {
+        security: {
+            jwtAuth: {
+                enabled: true,
+                secret: jwt.secret,
+                algorithm: jwt.algorithm || 'HS256',
+                issuer: jwt.issuer,
+                audience: jwt.audience,
+                expiresIn: jwt.expiresIn,
+                excludePaths: jwt.excludePaths || []
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+/**
+ * Route Utilities
+ *
+ * This file provides utility functions for working with route configurations,
+ * including merging, finding, and managing route collections.
+ */
+import type { IRouteConfig } from '../models/route-types.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 declare function mergeRouteConfigs(baseRoute: IRouteConfig, overrideRoute: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * 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 declare function routeMatchesDomain(route: IRouteConfig, domain: string): boolean;
+/**
+ * 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 declare function routeMatchesPort(route: IRouteConfig, port: number): boolean;
+/**
+ * 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 declare function routeMatchesPath(route: IRouteConfig, path: string): boolean;
+/**
+ * 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 declare function routeMatchesHeaders(route: IRouteConfig, headers: Record<string, string>): boolean;
+/**
+ * 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 declare function findMatchingRoutes(routes: IRouteConfig[], criteria: {
+    domain?: string;
+    port?: number;
+    path?: string;
+    headers?: Record<string, string>;
+}): IRouteConfig[];
+/**
+ * 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 declare function findBestMatchingRoute(routes: IRouteConfig[], criteria: {
+    domain?: string;
+    port?: number;
+    path?: string;
+    headers?: Record<string, string>;
+}): IRouteConfig | undefined;
+/**
+ * Create a route ID based on route properties
+ * @param route Route configuration
+ * @returns Generated route ID
+ */
+export declare function generateRouteId(route: IRouteConfig): string;
+/**
+ * Clone a route configuration
+ * @param route Route to clone
+ * @returns Deep copy of the route
+ */
+export declare function cloneRoute(route: IRouteConfig): IRouteConfig;