@push.rocks/smartproxy/dist_ts/proxies/smart-proxy/utils/route-helpers.js

A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.

/**
 * 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)
 * - API routes (createApiRoute)
 * - WebSocket routes (createWebSocketRoute)
 * - Port mapping routes (createPortMappingRoute, createOffsetPortMappingRoute)
 * - Dynamic routing (createDynamicRoute, createSmartLoadBalancer)
 * - NFTables routes (createNfTablesRoute, createNfTablesTerminateRoute)
 */
import * as plugins from '../../../plugins.js';
import { mergeRouteConfigs } from './route-utils.js';
import { ProtocolDetector, HttpDetector } from '../../../detection/index.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 function createHttpRoute(domains, target, options = {}) {
    // Create route match
    const match = {
        ports: options.match?.ports || 80,
        domains
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [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',
        targets: [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: 'socket-handler',
        socketHandler: SocketHandlers.httpRedirect(`https://{domain}:${httpsPort}{path}`, 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',
        targets: [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 backendsOrHosts Array of backend servers OR array of host strings (legacy)
 * @param portOrOptions Port number (legacy) OR options object
 * @param options Additional route options (legacy)
 * @returns Route configuration object
 */
export function createLoadBalancerRoute(domains, backendsOrHosts, portOrOptions, options) {
    // Handle legacy signature: (domains, hosts[], port, options)
    let backends;
    let finalOptions;
    if (Array.isArray(backendsOrHosts) && backendsOrHosts.length > 0 && typeof backendsOrHosts[0] === 'string') {
        // Legacy signature
        const hosts = backendsOrHosts;
        const port = portOrOptions;
        backends = hosts.map(host => ({ host, port }));
        finalOptions = options || {};
    }
    else {
        // New signature
        backends = backendsOrHosts;
        finalOptions = portOrOptions || {};
    }
    // Extract hosts and ensure all backends use the same port
    const port = backends[0].port;
    const hosts = backends.map(backend => backend.host);
    // Create route match
    const match = {
        ports: finalOptions.match?.ports || (finalOptions.tls || finalOptions.useTls ? 443 : 80),
        domains
    };
    // Create route target
    const target = {
        host: hosts,
        port
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [target]
    };
    // Add TLS configuration if provided
    if (finalOptions.tls || finalOptions.useTls) {
        action.tls = {
            mode: finalOptions.tls?.mode || 'terminate',
            certificate: finalOptions.tls?.certificate || finalOptions.certificate || 'auto'
        };
    }
    // Add load balancing options
    if (finalOptions.algorithm || finalOptions.healthCheck) {
        action.loadBalancing = {
            algorithm: finalOptions.algorithm || 'round-robin',
            healthCheck: finalOptions.healthCheck
        };
    }
    // Create the route config
    return {
        match,
        action,
        name: finalOptions.name || `Load Balancer for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
        ...finalOptions
    };
}
/**
 * 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',
        targets: [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 targetOrPath Target server OR WebSocket path (legacy)
 * @param targetOrOptions Target server (legacy) OR options
 * @param options Additional route options (legacy)
 * @returns Route configuration object
 */
export function createWebSocketRoute(domains, targetOrPath, targetOrOptions, options) {
    // Handle different signatures
    let target;
    let wsPath;
    let finalOptions;
    if (typeof targetOrPath === 'string') {
        // Legacy signature: (domains, path, target, options)
        wsPath = targetOrPath;
        target = targetOrOptions;
        finalOptions = options || {};
    }
    else {
        // New signature: (domains, target, options)
        target = targetOrPath;
        finalOptions = targetOrOptions || {};
        wsPath = finalOptions.path || '/ws';
    }
    // Normalize WebSocket path
    const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
    // Create route match
    const match = {
        ports: finalOptions.useTls
            ? (finalOptions.httpsPort || 443)
            : (finalOptions.httpPort || 80),
        domains,
        path: normalizedPath
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [target],
        websocket: {
            enabled: true,
            pingInterval: finalOptions.pingInterval || 30000, // 30 seconds
            pingTimeout: finalOptions.pingTimeout || 5000 // 5 seconds
        }
    };
    // Add TLS configuration if using HTTPS
    if (finalOptions.useTls) {
        action.tls = {
            mode: 'terminate',
            certificate: finalOptions.certificate || 'auto'
        };
    }
    // Create the route config
    return {
        match,
        action,
        name: finalOptions.name || `WebSocket Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
        priority: finalOptions.priority || 100, // Higher priority for WebSocket routes
        ...finalOptions
    };
}
/**
 * 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) {
    return (context) => 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) {
    // Create route match
    const match = {
        ports: options.sourcePortRange,
        domains: options.domains
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [{
                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) {
    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) {
    // Create route match
    const match = {
        ports: options.ports,
        domains: options.domains,
        path: options.path,
        clientIp: options.clientIp
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [{
                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) {
    // Extract all domain keys to create the match criteria
    const domains = Object.keys(options.domainTargets);
    // Create the smart host selector function
    const hostSelector = (context) => {
        const domain = context.domain || '';
        return options.domainTargets[domain] || options.defaultTarget || 'localhost';
    };
    // Create route match
    const match = {
        ports: options.ports,
        domains
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [{
                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
    };
}
/**
 * Create an NFTables-based route for high-performance packet forwarding
 * @param nameOrDomains Name or domain(s) to match
 * @param target Target host and port
 * @param options Additional route options
 * @returns Route configuration object
 */
export function createNfTablesRoute(nameOrDomains, target, options = {}) {
    // Determine if this is a name or domain
    let name;
    let domains;
    if (Array.isArray(nameOrDomains) || (typeof nameOrDomains === 'string' && nameOrDomains.includes('.'))) {
        domains = nameOrDomains;
        name = Array.isArray(nameOrDomains) ? nameOrDomains[0] : nameOrDomains;
    }
    else {
        name = nameOrDomains;
        domains = undefined; // No domains
    }
    // Create route match
    const match = {
        domains,
        ports: options.ports || 80
    };
    // Create route action
    const action = {
        type: 'forward',
        targets: [{
                host: target.host,
                port: target.port
            }],
        forwardingEngine: 'nftables',
        nftables: {
            protocol: options.protocol || 'tcp',
            preserveSourceIP: options.preserveSourceIP,
            maxRate: options.maxRate,
            priority: options.priority,
            tableName: options.tableName,
            useIPSets: options.useIPSets,
            useAdvancedNAT: options.useAdvancedNAT
        }
    };
    // Add TLS options if needed
    if (options.useTls) {
        action.tls = {
            mode: 'passthrough'
        };
    }
    // Create the route config
    const routeConfig = {
        name,
        match,
        action
    };
    // Add security if allowed or blocked IPs are specified
    if (options.ipAllowList?.length || options.ipBlockList?.length) {
        routeConfig.security = {
            ipAllowList: options.ipAllowList,
            ipBlockList: options.ipBlockList
        };
    }
    return routeConfig;
}
/**
 * Create an NFTables-based TLS termination route
 * @param nameOrDomains Name or domain(s) to match
 * @param target Target host and port
 * @param options Additional route options
 * @returns Route configuration object
 */
export function createNfTablesTerminateRoute(nameOrDomains, target, options = {}) {
    // Create basic NFTables route
    const route = createNfTablesRoute(nameOrDomains, target, {
        ...options,
        ports: options.ports || 443,
        useTls: false
    });
    // Set TLS termination
    route.action.tls = {
        mode: 'terminate',
        certificate: options.certificate || 'auto'
    };
    return route;
}
/**
 * Create a complete NFTables-based HTTPS setup with HTTP redirect
 * @param nameOrDomains Name or domain(s) to match
 * @param target Target host and port
 * @param options Additional route options
 * @returns Array of two route configurations (HTTPS and HTTP redirect)
 */
export function createCompleteNfTablesHttpsServer(nameOrDomains, target, options = {}) {
    // Create the HTTPS route using NFTables
    const httpsRoute = createNfTablesTerminateRoute(nameOrDomains, target, {
        ...options,
        ports: options.httpsPort || 443
    });
    // Determine the domain(s) for HTTP redirect
    const domains = typeof nameOrDomains === 'string' && !nameOrDomains.includes('.')
        ? undefined
        : nameOrDomains;
    // Extract the HTTPS port for the redirect destination
    const httpsPort = typeof options.httpsPort === 'number'
        ? options.httpsPort
        : Array.isArray(options.httpsPort) && typeof options.httpsPort[0] === 'number'
            ? options.httpsPort[0]
            : 443;
    // Create the HTTP redirect route (this uses standard forwarding, not NFTables)
    const httpRedirectRoute = createHttpToHttpsRedirect(domains, // Type cast needed since domains can be undefined now
    httpsPort, {
        match: {
            ports: options.httpPort || 80,
            domains: domains // Type cast needed since domains can be undefined now
        },
        name: `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains || 'all domains'}`
    });
    return [httpsRoute, httpRedirectRoute];
}
/**
 * Create a socket handler route configuration
 * @param domains Domain(s) to match
 * @param ports Port(s) to listen on
 * @param handler Socket handler function
 * @param options Additional route options
 * @returns Route configuration object
 */
export function createSocketHandlerRoute(domains, ports, handler, options = {}) {
    return {
        name: options.name || 'socket-handler-route',
        priority: options.priority !== undefined ? options.priority : 50,
        match: {
            domains,
            ports,
            ...(options.path && { path: options.path })
        },
        action: {
            type: 'socket-handler',
            socketHandler: handler
        }
    };
}
/**
 * Pre-built socket handlers for common use cases
 */
export const SocketHandlers = {
    /**
     * Simple echo server handler
     */
    echo: (socket, context) => {
        socket.write('ECHO SERVER READY\n');
        socket.on('data', data => socket.write(data));
    },
    /**
     * TCP proxy handler
     */
    proxy: (targetHost, targetPort) => (socket, context) => {
        const target = plugins.net.connect(targetPort, targetHost);
        socket.pipe(target);
        target.pipe(socket);
        socket.on('close', () => target.destroy());
        target.on('close', () => socket.destroy());
        target.on('error', (err) => {
            console.error('Proxy target error:', err);
            socket.destroy();
        });
    },
    /**
     * Line-based protocol handler
     */
    lineProtocol: (handler) => (socket, context) => {
        let buffer = '';
        socket.on('data', (data) => {
            buffer += data.toString();
            const lines = buffer.split('\n');
            buffer = lines.pop() || '';
            lines.forEach(line => {
                if (line.trim()) {
                    handler(line.trim(), socket);
                }
            });
        });
    },
    /**
     * Simple HTTP response handler (for testing)
     */
    httpResponse: (statusCode, body) => (socket, context) => {
        const response = [
            `HTTP/1.1 ${statusCode} ${statusCode === 200 ? 'OK' : 'Error'}`,
            'Content-Type: text/plain',
            `Content-Length: ${body.length}`,
            'Connection: close',
            '',
            body
        ].join('\r\n');
        socket.write(response);
        socket.end();
    },
    /**
     * Block connection immediately
     */
    block: (message) => (socket, context) => {
        const finalMessage = message || `Connection blocked from ${context.clientIp}`;
        if (finalMessage) {
            socket.write(finalMessage);
        }
        socket.end();
    },
    /**
     * HTTP block response
     */
    httpBlock: (statusCode = 403, message) => (socket, context) => {
        const defaultMessage = `Access forbidden for ${context.domain || context.clientIp}`;
        const finalMessage = message || defaultMessage;
        const response = [
            `HTTP/1.1 ${statusCode} ${finalMessage}`,
            'Content-Type: text/plain',
            `Content-Length: ${finalMessage.length}`,
            'Connection: close',
            '',
            finalMessage
        ].join('\r\n');
        socket.write(response);
        socket.end();
    },
    /**
     * HTTP redirect handler
     * Now uses the centralized detection module for HTTP parsing
     */
    httpRedirect: (locationTemplate, statusCode = 301) => (socket, context) => {
        const connectionId = ProtocolDetector.createConnectionId({
            socketId: context.connectionId || `${Date.now()}-${Math.random()}`
        });
        socket.once('data', async (data) => {
            // Use detection module for parsing
            const detectionResult = await ProtocolDetector.detectWithConnectionTracking(data, connectionId, { extractFullHeaders: false } // We only need method and path
            );
            if (detectionResult.protocol === 'http' && detectionResult.connectionInfo.path) {
                const method = detectionResult.connectionInfo.method || 'GET';
                const path = detectionResult.connectionInfo.path || '/';
                const domain = context.domain || 'localhost';
                const port = context.port;
                let finalLocation = locationTemplate
                    .replace('{domain}', domain)
                    .replace('{port}', String(port))
                    .replace('{path}', path)
                    .replace('{clientIp}', context.clientIp);
                const message = `Redirecting to ${finalLocation}`;
                const response = [
                    `HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
                    `Location: ${finalLocation}`,
                    'Content-Type: text/plain',
                    `Content-Length: ${message.length}`,
                    'Connection: close',
                    '',
                    message
                ].join('\r\n');
                socket.write(response);
            }
            else {
                // Not a valid HTTP request, close connection
                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
            }
            socket.end();
            // Clean up detection state
            ProtocolDetector.cleanupConnections();
        });
    },
    /**
     * HTTP server handler for ACME challenges and other HTTP needs
     * Now uses the centralized detection module for HTTP parsing
     */
    httpServer: (handler) => (socket, context) => {
        let requestParsed = false;
        const connectionId = ProtocolDetector.createConnectionId({
            socketId: context.connectionId || `${Date.now()}-${Math.random()}`
        });
        const processData = async (data) => {
            if (requestParsed)
                return; // Only handle the first request
            // Use HttpDetector for parsing
            const detectionResult = await ProtocolDetector.detectWithConnectionTracking(data, connectionId, { extractFullHeaders: true });
            if (detectionResult.protocol !== 'http' || !detectionResult.isComplete) {
                // Not a complete HTTP request yet
                return;
            }
            requestParsed = true;
            const connInfo = detectionResult.connectionInfo;
            // Create request object from detection result
            const req = {
                method: connInfo.method || 'GET',
                url: connInfo.path || '/',
                headers: connInfo.headers || {},
                body: detectionResult.remainingBuffer?.toString() || ''
            };
            // Create response object
            let statusCode = 200;
            const responseHeaders = {};
            let ended = false;
            const res = {
                status: (code) => {
                    statusCode = code;
                },
                header: (name, value) => {
                    responseHeaders[name] = value;
                },
                send: (data) => {
                    if (ended)
                        return;
                    ended = true;
                    if (!responseHeaders['content-type']) {
                        responseHeaders['content-type'] = 'text/plain';
                    }
                    responseHeaders['content-length'] = String(data.length);
                    responseHeaders['connection'] = 'close';
                    const statusText = statusCode === 200 ? 'OK' :
                        statusCode === 404 ? 'Not Found' :
                            statusCode === 500 ? 'Internal Server Error' : 'Response';
                    let response = `HTTP/1.1 ${statusCode} ${statusText}\r\n`;
                    for (const [name, value] of Object.entries(responseHeaders)) {
                        response += `${name}: ${value}\r\n`;
                    }
                    response += '\r\n';
                    response += data;
                    socket.write(response);
                    socket.end();
                },
                end: () => {
                    if (ended)
                        return;
                    ended = true;
                    socket.write('HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n');
                    socket.end();
                }
            };
            try {
                handler(req, res);
                // Ensure response is sent even if handler doesn't call send()
                setTimeout(() => {
                    if (!ended) {
                        res.send('');
                    }
                }, 1000);
            }
            catch (error) {
                if (!ended) {
                    res.status(500);
                    res.send('Internal Server Error');
                }
            }
        };
        socket.on('data', processData);
        socket.on('error', () => {
            if (!requestParsed) {
                socket.end();
            }
        });
        socket.on('close', () => {
            // Clean up detection state
            ProtocolDetector.cleanupConnections();
        });
    }
};
/**
 * 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 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,{"version":3,"file":"route-helpers.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-helpers.ts"],"names":[],"mappings":"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