@robiki/proxy 1.0.0

package/dist/config-_6LOsppp.d.ts

@@ -0,0 +1,180 @@
+import { OutgoingHttpHeaders, IncomingMessage } from 'node:http';
+import { IncomingHttpHeaders } from 'node:http2';
+import { TLSSocket } from 'node:tls';
+import WebSocket from 'ws';
+
+declare enum RequestType {
+    API = "api",
+    STREAM = "stream",
+    WEBSOCKET = "websocket"
+}
+interface TLSWebSocket extends WebSocket {
+    _socket: TLSSocket;
+}
+type Router = (req: any, res: any) => void;
+type WebSocketRouter = (req: IncomingMessage, socket: TLSWebSocket, headers: IncomingHttpHeaders) => void;
+type Streamer = (stream: any, headers: any, flags: any) => void;
+interface ForwardValidationResult {
+    status: boolean;
+    message?: string;
+    code?: number;
+    headers?: OutgoingHttpHeaders;
+}
+interface ConnectionInfo {
+    id: number;
+    method: string;
+    path: string;
+    remoteAddress: string;
+    scheme: string;
+    authority: string;
+    origin: string;
+    headers: IncomingHttpHeaders;
+    query: URLSearchParams;
+    type: RequestType;
+    respond: (status: number, headers?: Record<string, string>, body?: string) => void;
+    end: (body?: string) => void;
+}
+
+/**
+ * Route configuration for a specific domain/host
+ */
+interface RouteConfig {
+    /** Target host:port to proxy to */
+    target: string;
+    /** Enable SSL/TLS for the target */
+    ssl?: boolean;
+    /** Remap the URL path before forwarding */
+    remap?: (url: string) => string;
+    /** Custom CORS configuration */
+    cors?: CorsConfig;
+    /** Validation function for this route */
+    validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+}
+/**
+ * CORS configuration
+ */
+interface CorsConfig {
+    /** Allowed origins (array of strings or '*' for all) */
+    origin?: string | string[];
+    /** Allowed HTTP methods */
+    methods?: string[];
+    /** Allowed headers */
+    allowedHeaders?: string[];
+    /** Exposed headers */
+    exposedHeaders?: string[];
+    /** Allow credentials */
+    credentials?: boolean;
+    /** Max age for preflight cache */
+    maxAge?: number;
+}
+/**
+ * SSL/TLS certificate configuration
+ */
+interface CertificateConfig {
+    /** Path to private key file or key content */
+    key: string;
+    /** Path to certificate file or cert content */
+    cert: string;
+    /** Path to CA file or CA content */
+    ca?: string;
+    /** Allow HTTP/1.1 fallback */
+    allowHTTP1?: boolean;
+}
+/**
+ * Server configuration
+ */
+interface ServerConfig {
+    /** SSL/TLS certificate configuration */
+    ssl?: CertificateConfig;
+    /** Route configurations mapped by host */
+    routes: Record<string, RouteConfig>;
+    /** Default CORS configuration */
+    cors?: CorsConfig;
+    /** Global validation function */
+    validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+}
+/**
+ * Proxy configuration manager
+ */
+declare class ProxyConfig {
+    private config;
+    private sslConfig?;
+    constructor(config: ServerConfig);
+    /**
+     * Initialize SSL configuration
+     */
+    private initializeSSL;
+    /**
+     * Get SSL configuration
+     */
+    getSSL(): {
+        key: Buffer;
+        cert: Buffer;
+        ca?: Buffer;
+        allowHTTP1?: boolean;
+    } | undefined;
+    /**
+     * Get route configuration for a host
+     */
+    getRoute(host: string): RouteConfig | undefined;
+    /**
+     * Get target for a host
+     */
+    getTarget(host: string): {
+        target: undefined;
+        ssl: undefined;
+        remap: undefined;
+    } | {
+        target: string;
+        ssl: {
+            key: Buffer;
+            cert: Buffer;
+            ca?: Buffer;
+            allowHTTP1?: boolean;
+        } | undefined;
+        remap: ((url: string) => string) | undefined;
+    };
+    /**
+     * Get CORS headers for a request
+     */
+    getCorsHeaders(origin: string, host?: string): OutgoingHttpHeaders;
+    /**
+     * Validate a request
+     */
+    validate(info: ConnectionInfo): Promise<ForwardValidationResult>;
+    /**
+     * Get ports to listen on
+     */
+    getPorts(): number[];
+    /**
+     * Get the full configuration
+     */
+    getConfig(): ServerConfig;
+}
+/**
+ * Initialize the global configuration
+ */
+declare function initConfig(config: ServerConfig): ProxyConfig;
+/**
+ * Get the global configuration
+ */
+declare function getConfig(): ProxyConfig;
+/**
+ * Load configuration with cascading priority:
+ * 1. Programmatic config (highest priority)
+ * 2. Environment variables
+ * 3. Config file
+ * 4. Defaults (lowest priority)
+ */
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): ProxyConfig;
+/**
+ * Load configuration from a file (deprecated - use loadConfig instead)
+ */
+declare function loadConfigFromFile(path: string): ProxyConfig;
+/**
+ * Load configuration from environment variables (deprecated - use loadConfig instead)
+ */
+declare function loadConfigFromEnv(): ProxyConfig;
+
+export { ProxyConfig as P, RequestType as e, loadConfigFromFile as f, getConfig as g, loadConfigFromEnv as h, initConfig as i, loadConfig as l };
+export type { CorsConfig as C, ForwardValidationResult as F, Router as R, ServerConfig as S, TLSWebSocket as T, WebSocketRouter as W, Streamer as a, RouteConfig as b, CertificateConfig as c, ConnectionInfo as d };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { T as TLSWebSocket, P as ProxyConfig, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-_6LOsppp.js';
+export { c as CertificateConfig, d as ConnectionInfo, C as CorsConfig, F as ForwardValidationResult, e as RequestType, b as RouteConfig, g as getConfig, l as loadConfig } from './config-_6LOsppp.js';
+import { IncomingMessage, ServerResponse, IncomingHttpHeaders as IncomingHttpHeaders$1 } from 'node:http';
+import { ServerHttp2Stream, IncomingHttpHeaders } from 'node:http2';
+import 'node:tls';
+import 'ws';
+
+declare const restAPIProxyHandler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+declare const streamAPIProxyHandler: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders) => Promise<void>;
+
+declare const websocketAPIProxyHandler: (req: IncomingMessage, socket: TLSWebSocket, headers: IncomingHttpHeaders$1) => Promise<void>;
+
+/**
+ * Proxy server instance
+ */
+declare class ProxyServer {
+    private config;
+    private servers;
+    constructor(config: ProxyConfig);
+    /**
+     * Start the proxy server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the proxy server
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the configuration
+     */
+    getConfig(): ProxyConfig;
+}
+/**
+ * Create and start a proxy server
+ */
+declare function createProxy(config?: Partial<ServerConfig>): Promise<ProxyServer>;
+/**
+ * Create a proxy server with custom handlers
+ */
+declare function createCustomProxy(config: Partial<ServerConfig> | undefined, handlers: {
+    rest?: Router;
+    stream?: Streamer;
+    websocket?: WebSocketRouter;
+}): Promise<ProxyServer>;
+
+export { ProxyConfig, ProxyServer, Router, ServerConfig, Streamer, WebSocketRouter, createCustomProxy, createProxy, restAPIProxyHandler, streamAPIProxyHandler, websocketAPIProxyHandler };