@push.rocks/smartproxy 10.2.0 → 12.0.0

package/ts/smartproxy/types/forwarding.types.ts

@@ -0,0 +1,162 @@
+import type * as plugins from '../../plugins.js';
+
+/**
+ * The primary forwarding types supported by SmartProxy
+ */
+export type ForwardingType =
+  | 'http-only'                // HTTP forwarding only (no HTTPS)
+  | 'https-passthrough'        // Pass-through TLS traffic (SNI forwarding)
+  | 'https-terminate-to-http'  // Terminate TLS and forward to HTTP backend
+  | 'https-terminate-to-https'; // Terminate TLS and forward to HTTPS backend
+
+/**
+ * Target configuration for forwarding
+ */
+export interface ITargetConfig {
+  host: string | string[];  // Support single host or round-robin
+  port: number;
+}
+
+/**
+ * HTTP-specific options for forwarding
+ */
+export interface IHttpOptions {
+  enabled?: boolean;                 // Whether HTTP is enabled
+  redirectToHttps?: boolean;         // Redirect HTTP to HTTPS
+  headers?: Record<string, string>;  // Custom headers for HTTP responses
+}
+
+/**
+ * HTTPS-specific options for forwarding
+ */
+export interface IHttpsOptions {
+  customCert?: {                    // Use custom cert instead of auto-provisioned
+    key: string;
+    cert: string;
+  };
+  forwardSni?: boolean;             // Forward SNI info in passthrough mode
+}
+
+/**
+ * ACME certificate handling options
+ */
+export interface IAcmeForwardingOptions {
+  enabled?: boolean;                // Enable ACME certificate provisioning  
+  maintenance?: boolean;            // Auto-renew certificates
+  production?: boolean;             // Use production ACME servers
+  forwardChallenges?: {             // Forward ACME challenges
+    host: string;
+    port: number;
+    useTls?: boolean;
+  };
+}
+
+/**
+ * Security options for forwarding
+ */
+export interface ISecurityOptions {
+  allowedIps?: string[];            // IPs allowed to connect
+  blockedIps?: string[];            // IPs blocked from connecting
+  maxConnections?: number;          // Max simultaneous connections
+}
+
+/**
+ * Advanced options for forwarding
+ */
+export interface IAdvancedOptions {
+  portRanges?: Array<{ from: number; to: number }>; // Allowed port ranges
+  networkProxyPort?: number;        // Custom NetworkProxy port if using terminate mode
+  keepAlive?: boolean;              // Enable TCP keepalive
+  timeout?: number;                 // Connection timeout in ms
+  headers?: Record<string, string>; // Custom headers with support for variables like {sni}
+}
+
+/**
+ * Unified forwarding configuration interface
+ */
+export interface IForwardConfig {
+  // Define the primary forwarding type - use-case driven approach
+  type: ForwardingType;
+  
+  // Target configuration
+  target: ITargetConfig;
+  
+  // Protocol options
+  http?: IHttpOptions;
+  https?: IHttpsOptions;
+  acme?: IAcmeForwardingOptions;
+  
+  // Security and advanced options
+  security?: ISecurityOptions;
+  advanced?: IAdvancedOptions;
+}
+
+/**
+ * Event types emitted by forwarding handlers
+ */
+export enum ForwardingHandlerEvents {
+  CONNECTED = 'connected',
+  DISCONNECTED = 'disconnected',
+  ERROR = 'error',
+  DATA_FORWARDED = 'data-forwarded',
+  HTTP_REQUEST = 'http-request',
+  HTTP_RESPONSE = 'http-response',
+  CERTIFICATE_NEEDED = 'certificate-needed',
+  CERTIFICATE_LOADED = 'certificate-loaded'
+}
+
+/**
+ * Base interface for forwarding handlers
+ */
+export interface IForwardingHandler extends plugins.EventEmitter {
+  initialize(): Promise<void>;
+  handleConnection(socket: plugins.net.Socket): void;
+  handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+}
+
+/**
+ * Helper function types for common forwarding patterns
+ */
+export const httpOnly = (
+  partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, 'target'>
+): IForwardConfig => ({
+  type: 'http-only',
+  target: partialConfig.target,
+  http: { enabled: true, ...(partialConfig.http || {}) },
+  ...(partialConfig.security ? { security: partialConfig.security } : {}),
+  ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+
+export const tlsTerminateToHttp = (
+  partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, 'target'>
+): IForwardConfig => ({
+  type: 'https-terminate-to-http',
+  target: partialConfig.target,
+  https: { ...(partialConfig.https || {}) },
+  acme: { enabled: true, maintenance: true, ...(partialConfig.acme || {}) },
+  http: { enabled: true, redirectToHttps: true, ...(partialConfig.http || {}) },
+  ...(partialConfig.security ? { security: partialConfig.security } : {}),
+  ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+
+export const tlsTerminateToHttps = (
+  partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, 'target'>
+): IForwardConfig => ({
+  type: 'https-terminate-to-https',
+  target: partialConfig.target,
+  https: { ...(partialConfig.https || {}) },
+  acme: { enabled: true, maintenance: true, ...(partialConfig.acme || {}) },
+  http: { enabled: true, redirectToHttps: true, ...(partialConfig.http || {}) },
+  ...(partialConfig.security ? { security: partialConfig.security } : {}),
+  ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+
+export const httpsPassthrough = (
+  partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, 'target'>
+): IForwardConfig => ({
+  type: 'https-passthrough',
+  target: partialConfig.target,
+  https: { forwardSni: true, ...(partialConfig.https || {}) },
+  ...(partialConfig.security ? { security: partialConfig.security } : {}),
+  ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});