@push.rocks/smartproxy 21.1.7 → 22.4.2

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

@@ -0,0 +1,124 @@
+/**
+ * Dynamic Route Helper Functions
+ *
+ * This module provides utility functions for creating dynamic routes
+ * with context-based host and port mapping.
+ */
+
+import type { IRouteConfig, IRouteMatch, IRouteAction, TPortRange, IRouteContext } from '../../models/route-types.js';
+
+/**
+ * Create a helper function that applies a port offset
+ * @param offset The offset to apply to the matched port
+ * @returns A function that adds the offset to the matched port
+ */
+export function createPortOffset(offset: number): (context: IRouteContext) => number {
+  return (context: IRouteContext) => context.port + offset;
+}
+
+/**
+ * Create a port mapping route with context-based port function
+ * @param options Port mapping route options
+ * @returns Route configuration object
+ */
+export function createPortMappingRoute(options: {
+  sourcePortRange: TPortRange;
+  targetHost: string | string[] | ((context: IRouteContext) => string | string[]);
+  portMapper: (context: IRouteContext) => number;
+  name?: string;
+  domains?: string | string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.sourcePortRange,
+    domains: options.domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    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: {
+  ports: TPortRange;
+  targetHost: string | string[];
+  offset: number;
+  name?: string;
+  domains?: string | string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  return createPortMappingRoute({
+    sourcePortRange: options.ports,
+    targetHost: options.targetHost,
+    portMapper: (context) => context.port + options.offset,
+    name: options.name || `Offset Mapping (${options.offset > 0 ? '+' : ''}${options.offset}) for ${options.domains || 'all domains'}`,
+    domains: options.domains,
+    priority: options.priority,
+    ...options
+  });
+}
+
+/**
+ * Create a dynamic route with context-based host and port mapping
+ * @param options Dynamic route options
+ * @returns Route configuration object
+ */
+export function createDynamicRoute(options: {
+  ports: TPortRange;
+  targetHost: (context: IRouteContext) => string | string[];
+  portMapper: (context: IRouteContext) => number;
+  name?: string;
+  domains?: string | string[];
+  path?: string;
+  clientIp?: string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.ports,
+    domains: options.domains,
+    path: options.path,
+    clientIp: options.clientIp
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    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
+  };
+}

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

@@ -0,0 +1,40 @@
+/**
+ * HTTP Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTP route configurations.
+ */
+
+import type { IRouteConfig, IRouteMatch, IRouteAction } 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 function createHttpRoute(
+  domains: string | string[],
+  target: { host: string | string[]; port: number },
+  options: Partial<IRouteConfig> = {}
+): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.match?.ports || 80,
+    domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    targets: [target]
+  };
+
+  // Create the route config
+  return {
+    match,
+    action,
+    name: options.name || `HTTP Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+    ...options
+  };
+}

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

@@ -0,0 +1,163 @@
+/**
+ * HTTPS Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTPS route configurations
+ * including TLS termination and passthrough routes.
+ */
+
+import type { IRouteConfig, IRouteMatch, IRouteAction } from '../../models/route-types.js';
+import { SocketHandlers } from './socket-handlers.js';
+
+/**
+ * Create an HTTPS route with 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 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 route match
+  const match: IRouteMatch = {
+    ports: options.httpsPort || 443,
+    domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    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: string | string[],
+  httpsPort: number = 443,
+  options: Partial<IRouteConfig> = {}
+): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.match?.ports || 80,
+    domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    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: string | string[],
+  target: { host: string | string[]; port: number },
+  options: Partial<IRouteConfig> = {}
+): IRouteConfig {
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.match?.ports || 443,
+    domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    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: 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 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];
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Route Helper Functions
+ *
+ * This module 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 barrel file re-exports all helper functions for backwards compatibility.
+ */
+
+// HTTP helpers
+export { createHttpRoute } from './http-helpers.js';
+
+// HTTPS helpers
+export {
+  createHttpsTerminateRoute,
+  createHttpToHttpsRedirect,
+  createHttpsPassthroughRoute,
+  createCompleteHttpsServer
+} from './https-helpers.js';
+
+// WebSocket helpers
+export { createWebSocketRoute } from './websocket-helpers.js';
+
+// Load balancer helpers
+export {
+  createLoadBalancerRoute,
+  createSmartLoadBalancer
+} from './load-balancer-helpers.js';
+
+// NFTables helpers
+export {
+  createNfTablesRoute,
+  createNfTablesTerminateRoute,
+  createCompleteNfTablesHttpsServer
+} from './nftables-helpers.js';
+
+// Dynamic routing helpers
+export {
+  createPortOffset,
+  createPortMappingRoute,
+  createOffsetPortMappingRoute,
+  createDynamicRoute
+} from './dynamic-helpers.js';
+
+// API helpers
+export {
+  createApiRoute,
+  createApiGatewayRoute
+} from './api-helpers.js';
+
+// Security helpers
+export {
+  addRateLimiting,
+  addBasicAuth,
+  addJwtAuth
+} from './security-helpers.js';
+
+// Socket handlers
+export {
+  SocketHandlers,
+  createSocketHandlerRoute
+} from './socket-handlers.js';

package/ts/proxies/smart-proxy/utils/route-helpers/load-balancer-helpers.ts

@@ -0,0 +1,154 @@
+/**
+ * Load Balancer Route Helper Functions
+ *
+ * This module provides utility functions for creating load balancer route configurations.
+ */
+
+import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget, TPortRange, IRouteContext } from '../../models/route-types.js';
+
+/**
+ * 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: string | string[],
+  backendsOrHosts: Array<{ host: string; port: number }> | string[],
+  portOrOptions?: number | {
+    tls?: {
+      mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+      certificate?: 'auto' | { key: string; cert: string };
+    };
+    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;
+  },
+  options?: {
+    tls?: {
+      mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+      certificate?: 'auto' | { key: string; cert: string };
+    };
+    [key: string]: any;
+  }
+): IRouteConfig {
+  // Handle legacy signature: (domains, hosts[], port, options)
+  let backends: Array<{ host: string; port: number }>;
+  let finalOptions: any;
+
+  if (Array.isArray(backendsOrHosts) && backendsOrHosts.length > 0 && typeof backendsOrHosts[0] === 'string') {
+    // Legacy signature
+    const hosts = backendsOrHosts as string[];
+    const port = portOrOptions as number;
+    backends = hosts.map(host => ({ host, port }));
+    finalOptions = options || {};
+  } else {
+    // New signature
+    backends = backendsOrHosts as Array<{ host: string; port: number }>;
+    finalOptions = (portOrOptions as any) || {};
+  }
+
+  // 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: IRouteMatch = {
+    ports: finalOptions.match?.ports || (finalOptions.tls || finalOptions.useTls ? 443 : 80),
+    domains
+  };
+
+  // Create route target
+  const target: IRouteTarget = {
+    host: hosts,
+    port
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    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 a smart load balancer with dynamic domain-based backend selection
+ * @param options Smart load balancer options
+ * @returns Route configuration object
+ */
+export function createSmartLoadBalancer(options: {
+  ports: TPortRange;
+  domainTargets: Record<string, string | string[]>;
+  portMapper: (context: IRouteContext) => number;
+  name?: string;
+  defaultTarget?: string | string[];
+  priority?: number;
+  [key: string]: any;
+}): IRouteConfig {
+  // Extract all domain keys to create the match criteria
+  const domains = Object.keys(options.domainTargets);
+
+  // Create the smart host selector function
+  const hostSelector = (context: IRouteContext) => {
+    const domain = context.domain || '';
+    return options.domainTargets[domain] || options.defaultTarget || 'localhost';
+  };
+
+  // Create route match
+  const match: IRouteMatch = {
+    ports: options.ports,
+    domains
+  };
+
+  // Create route action
+  const action: IRouteAction = {
+    type: 'forward',
+    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
+  };
+}