@robiki/proxy 1.0.2 → 1.0.4

package/dist/{config-CeJ1tf8T.d.ts → config-Bmt0asXb.d.ts}

@@ -154,21 +154,15 @@ declare class ProxyConfig {
     getConfig(): ServerConfig;
 }
 /**
- * Load configuration with cascading priority:
+ * Load configuration with cascading priority (async):
  * 1. Programmatic config (highest priority)
  * 2. Environment variables
  * 3. Config file
  * 4. Defaults (lowest priority)
+ *
+ * Supports config file types: .json, .ts, .js
  */
-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;
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): Promise<ProxyConfig>;
 
-export { ProxyConfig as P, RequestType as e, loadConfigFromFile as f, loadConfigFromEnv as g, loadConfig as l };
+export { ProxyConfig as P, RequestType as e, 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/config-C-0wrirG.js

@@ -0,0 +1,315 @@
+import { stat, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+function debug(message, data) {
+  if (process.env.DEBUG === "true") {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (data !== void 0) {
+      const sanitized = JSON.stringify(data, (_, value) => typeof value === "function" ? "<function>" : value, 2);
+      return console.log(`[${timestamp}] [CONFIG] ${message}`, sanitized);
+    }
+    return console.log(`[${timestamp}] [CONFIG] ${message}`);
+  }
+}
+
+function loadSSLKey(keyConfig) {
+  debug(`Loading SSL key from: ${keyConfig.includes("-----BEGIN") ? "inline" : keyConfig}`);
+  return keyConfig.includes("-----BEGIN") ? Promise.resolve(Buffer.from(keyConfig)) : readFile(resolve(keyConfig));
+}
+function loadSSLCert(certConfig) {
+  debug(`Loading SSL cert from: ${certConfig.includes("-----BEGIN") ? "inline" : certConfig}`);
+  return certConfig.includes("-----BEGIN") ? Promise.resolve(Buffer.from(certConfig)) : readFile(resolve(certConfig));
+}
+function loadSSLCA(caConfig) {
+  if (!caConfig) {
+    debug("Loading SSL CA from: none");
+    return Promise.resolve(void 0);
+  }
+  debug(`Loading SSL CA from: ${caConfig.includes("-----BEGIN") ? "inline" : caConfig}`);
+  return caConfig.includes("-----BEGIN") ? Promise.resolve(Buffer.from(caConfig)) : readFile(resolve(caConfig));
+}
+function initializeSSL(sslConfig) {
+  debug("Initializing SSL configuration...");
+  return Promise.all([loadSSLKey(sslConfig.key), loadSSLCert(sslConfig.cert), loadSSLCA(sslConfig.ca)]).then(([key, cert, ca]) => {
+    const loaded = {
+      key,
+      cert,
+      ca,
+      allowHTTP1: sslConfig.allowHTTP1 ?? true
+    };
+    debug("SSL configuration loaded successfully", {
+      keySize: key.length,
+      certSize: cert.length,
+      caSize: ca?.length || 0,
+      allowHTTP1: loaded.allowHTTP1
+    });
+    return loaded;
+  }).catch((error) => {
+    debug("Failed to load SSL certificates", error);
+    console.error("Failed to load SSL certificates:", error);
+    throw error;
+  });
+}
+function getRoute(config, host) {
+  if (config.routes[host]) {
+    return config.routes[host];
+  }
+  const hostWithoutPort = host.split(":")[0];
+  if (config.routes[hostWithoutPort]) {
+    return config.routes[hostWithoutPort];
+  }
+  for (const [pattern, route] of Object.entries(config.routes)) {
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      if (regex.test(host) || regex.test(hostWithoutPort)) {
+        return route;
+      }
+    }
+  }
+  return void 0;
+}
+function getTarget(config, sslConfig, host) {
+  const route = getRoute(config, host);
+  if (!route) {
+    return { target: void 0, ssl: void 0, remap: void 0 };
+  }
+  return {
+    target: route.target,
+    ssl: route.ssl ? sslConfig : void 0,
+    remap: route.remap
+  };
+}
+function getCorsHeaders(config, origin, host) {
+  const route = host ? getRoute(config, host) : void 0;
+  const corsConfig = route?.cors || config.cors;
+  if (!corsConfig) {
+    return {
+      "access-control-allow-origin": origin,
+      "access-control-allow-methods": "*",
+      "access-control-allow-headers": "*",
+      "access-control-allow-credentials": "true"
+    };
+  }
+  const headers = {};
+  if (corsConfig.origin === "*") {
+    headers["access-control-allow-origin"] = "*";
+  } else if (Array.isArray(corsConfig.origin)) {
+    if (corsConfig.origin.includes(origin)) {
+      headers["access-control-allow-origin"] = origin;
+    }
+  } else if (corsConfig.origin) {
+    headers["access-control-allow-origin"] = corsConfig.origin;
+  } else {
+    headers["access-control-allow-origin"] = origin;
+  }
+  if (corsConfig.methods) {
+    headers["access-control-allow-methods"] = corsConfig.methods.join(", ");
+  } else {
+    headers["access-control-allow-methods"] = "*";
+  }
+  if (corsConfig.allowedHeaders) {
+    headers["access-control-allow-headers"] = corsConfig.allowedHeaders.join(", ");
+  } else {
+    headers["access-control-allow-headers"] = "*";
+  }
+  if (corsConfig.exposedHeaders) {
+    headers["access-control-expose-headers"] = corsConfig.exposedHeaders.join(", ");
+  }
+  if (corsConfig.credentials !== void 0) {
+    headers["access-control-allow-credentials"] = corsConfig.credentials ? "true" : "false";
+  } else {
+    headers["access-control-allow-credentials"] = "true";
+  }
+  if (corsConfig.maxAge) {
+    headers["access-control-max-age"] = corsConfig.maxAge.toString();
+  }
+  return headers;
+}
+function validateRequest(config, info) {
+  const route = getRoute(config, info.authority);
+  if (route?.validate) return route.validate(info);
+  if (config.validate) return config.validate(info);
+  return Promise.resolve({ status: true });
+}
+function getPorts(config) {
+  return config.ports || [443, 8080, 9229];
+}
+function createProxyConfig(config, sslConfig) {
+  return {
+    config,
+    sslConfig,
+    getSSL: () => sslConfig,
+    getRoute: (host) => getRoute(config, host),
+    getTarget: (host) => getTarget(config, sslConfig, host),
+    getCorsHeaders: (origin, host) => getCorsHeaders(config, origin, host),
+    validate: (info) => validateRequest(config, info),
+    getPorts: () => getPorts(config),
+    getConfig: () => config
+  };
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj) continue;
+    for (const key in obj) {
+      if (obj[key] === void 0) continue;
+      if (typeof obj[key] === "object" && !Array.isArray(obj[key]) && obj[key] !== null) {
+        result[key] = deepMerge(result[key] || {}, obj[key]);
+      } else {
+        result[key] = obj[key];
+      }
+    }
+  }
+  return result;
+}
+function getConfigFromEnv() {
+  debug("Loading configuration from environment variables...");
+  const config = {};
+  if (process.env.SSL_KEY && process.env.SSL_CERT) {
+    debug("Found SSL configuration in environment variables");
+    config.ssl = {
+      key: process.env.SSL_KEY,
+      cert: process.env.SSL_CERT,
+      ca: process.env.SSL_CA,
+      allowHTTP1: process.env.SSL_ALLOW_HTTP1 === "true"
+    };
+  }
+  if (process.env.CORS_ORIGIN) {
+    debug("Found CORS configuration in environment variables", {
+      origin: process.env.CORS_ORIGIN,
+      methods: process.env.CORS_METHODS,
+      headers: process.env.CORS_HEADERS,
+      credentials: process.env.CORS_CREDENTIALS
+    });
+    config.cors = {
+      origin: process.env.CORS_ORIGIN === "*" ? "*" : process.env.CORS_ORIGIN.split(","),
+      methods: process.env.CORS_METHODS?.split(","),
+      allowedHeaders: process.env.CORS_HEADERS?.split(","),
+      credentials: process.env.CORS_CREDENTIALS === "true"
+    };
+  }
+  if (Object.keys(config).length === 0) {
+    debug("No configuration found in environment variables");
+  }
+  return config;
+}
+async function getConfigFromFile() {
+  const configPath = process.env.PROXY_CONFIG || "./proxy.config.json";
+  const resolvedPath = resolve(configPath);
+  debug(`Looking for config file at: ${resolvedPath}`);
+  try {
+    const stats = await stat(resolvedPath);
+    debug(`Config file found (${stats.size} bytes)`);
+    if (resolvedPath.endsWith(".json")) {
+      debug("Loading JSON config file...");
+      const configFile2 = await readFile(resolvedPath, "utf-8");
+      const config2 = JSON.parse(configFile2);
+      debug("JSON config loaded successfully", {
+        routes: Object.keys(config2.routes || {}),
+        hasCors: !!config2.cors,
+        hasSsl: !!config2.ssl,
+        ports: config2.ports
+      });
+      return config2;
+    }
+    if (resolvedPath.endsWith(".ts") || resolvedPath.endsWith(".js")) {
+      const fileType = resolvedPath.endsWith(".ts") ? "TypeScript" : "JavaScript";
+      debug(`Loading ${fileType} config file...`);
+      const configModule = await import(`file://${resolvedPath}`);
+      const config2 = configModule.default || configModule;
+      debug(`${fileType} config loaded successfully`, {
+        routes: Object.keys(config2.routes || {}),
+        hasCors: !!config2.cors,
+        hasSsl: !!config2.ssl,
+        ports: config2.ports
+      });
+      return config2;
+    }
+    debug("Loading config as JSON (no extension match)...");
+    const configFile = await readFile(resolvedPath, "utf-8");
+    const config = JSON.parse(configFile);
+    debug("Config loaded successfully", {
+      routes: Object.keys(config.routes || {}),
+      hasCors: !!config.cors,
+      hasSsl: !!config.ssl,
+      ports: config.ports
+    });
+    return config;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      debug(`Config file not found: ${resolvedPath}`);
+    } else {
+      debug(`Error loading config file: ${error.message}`);
+    }
+    return {};
+  }
+}
+function loadDefaults() {
+  debug("==========================================");
+  debug("Starting configuration loading process...");
+  debug("==========================================");
+  debug("Step 1: Loading default configuration...");
+  const defaults = {
+    routes: {},
+    cors: {
+      origin: "*",
+      credentials: true
+    }
+  };
+  debug("Defaults loaded", defaults);
+  return defaults;
+}
+function loadAndMergeFileConfig(defaults) {
+  debug("Step 2: Loading configuration from file...");
+  return getConfigFromFile().then((fileConfig) => {
+    if (Object.keys(fileConfig).length > 0) {
+      debug("File config loaded", fileConfig);
+    } else {
+      debug("No file configuration loaded");
+    }
+    return deepMerge(defaults, fileConfig);
+  });
+}
+function mergeEnvConfig(config) {
+  debug("Step 3: Loading configuration from environment...");
+  const envConfig = getConfigFromEnv();
+  return deepMerge(config, envConfig);
+}
+function mergeProgrammaticConfig(config, programmaticConfig) {
+  if (programmaticConfig && Object.keys(programmaticConfig).length > 0) {
+    debug("Step 4: Programmatic configuration provided", programmaticConfig);
+    return deepMerge(config, programmaticConfig);
+  }
+  return config;
+}
+function logMergedConfig(merged) {
+  debug("Step 5: Final merged configuration", {
+    routes: Object.keys(merged.routes || {}),
+    ports: merged.ports,
+    hasCors: !!merged.cors,
+    hasSsl: !!merged.ssl,
+    hasValidate: !!merged.validate
+  });
+  return merged;
+}
+function initializeSSLIfConfigured(config) {
+  debug("Step 6: Checking SSL configuration...");
+  if (!config.ssl) {
+    debug("No SSL configuration provided");
+    return Promise.resolve({ config, sslConfig: void 0 });
+  }
+  return initializeSSL(config.ssl).then((sslConfig) => ({ config, sslConfig }));
+}
+function createFinalConfig({ config, sslConfig }) {
+  debug("Step 7: Creating ProxyConfig object...");
+  const proxyConfig = createProxyConfig(config, sslConfig);
+  debug("==========================================");
+  debug("Configuration loading completed successfully");
+  debug("==========================================");
+  return proxyConfig;
+}
+function loadConfig(programmaticConfig) {
+  return Promise.resolve(loadDefaults()).then((defaults) => loadAndMergeFileConfig(defaults)).then((config) => mergeEnvConfig(config)).then((config) => mergeProgrammaticConfig(config, programmaticConfig)).then((merged) => logMergedConfig(merged)).then((merged) => initializeSSLIfConfigured(merged)).then((result) => createFinalConfig(result));
+}
+
+export { debug as d, loadConfig as l };

package/dist/{config-CQ7zIaQt.d.ts → config-CCOdQL7F.d.ts}

@@ -92,6 +92,8 @@ interface ServerConfig {
     cors?: CorsConfig;
     /** Global validation function */
     validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+    /** Ports to listen on (defaults to [443, 8080, 9229]) */
+    ports?: number[];
 }
 /**
  * Proxy configuration manager
@@ -152,21 +154,15 @@ declare class ProxyConfig {
     getConfig(): ServerConfig;
 }
 /**
- * Load configuration with cascading priority:
+ * Load configuration with cascading priority (async):
  * 1. Programmatic config (highest priority)
  * 2. Environment variables
  * 3. Config file
  * 4. Defaults (lowest priority)
+ *
+ * Supports all config file types: .json, .cjs, .ts, .js, .mjs
  */
-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;
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): Promise<ProxyConfig>;
 
-export { ProxyConfig as P, RequestType as e, loadConfigFromFile as f, loadConfigFromEnv as g, loadConfig as l };
+export { ProxyConfig as P, RequestType as e, 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/{config-_6LOsppp.d.ts → config-DtfpOtWI.d.ts}

@@ -92,89 +92,46 @@ interface ServerConfig {
     cors?: CorsConfig;
     /** Global validation function */
     validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+    /** Ports to listen on (defaults to [443, 8080, 9229]) */
+    ports?: number[];
 }
 /**
- * Proxy configuration manager
+ * Processed SSL configuration with loaded certificates
  */
-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;
+interface LoadedSSLConfig {
+    key: Buffer;
+    cert: Buffer;
+    ca?: Buffer;
+    allowHTTP1: boolean;
 }
 /**
- * Initialize the global configuration
- */
-declare function initConfig(config: ServerConfig): ProxyConfig;
-/**
- * Get the global configuration
+ * Proxy configuration object with loaded SSL
  */
-declare function getConfig(): ProxyConfig;
+interface ProxyConfig {
+    config: ServerConfig;
+    sslConfig?: LoadedSSLConfig;
+    getSSL: () => LoadedSSLConfig | undefined;
+    getRoute: (host: string) => RouteConfig | undefined;
+    getTarget: (host: string) => {
+        target: string | undefined;
+        ssl: LoadedSSLConfig | undefined;
+        remap: ((url: string) => string) | undefined;
+    };
+    getCorsHeaders: (origin: string, host?: string) => OutgoingHttpHeaders;
+    validate: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+    getPorts: () => number[];
+    getConfig: () => ServerConfig;
+}
 /**
- * Load configuration with cascading priority:
+ * Load configuration with cascading priority using promise chain:
  * 1. Programmatic config (highest priority)
  * 2. Environment variables
  * 3. Config file
  * 4. Defaults (lowest priority)
+ *
+ * Supports config file types: .json, .ts, .js
  */
-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;
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): Promise<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 };
+export { RequestType as e, loadConfig as l };
+export type { CorsConfig as C, ForwardValidationResult as F, LoadedSSLConfig as L, ProxyConfig as P, 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

@@ -1,5 +1,5 @@
-import { P as ProxyConfig, T as TLSWebSocket, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-CeJ1tf8T.js';
-export { c as CertificateConfig, d as ConnectionInfo, C as CorsConfig, F as ForwardValidationResult, e as RequestType, b as RouteConfig, l as loadConfig } from './config-CeJ1tf8T.js';
+import { P as ProxyConfig, T as TLSWebSocket, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-DtfpOtWI.js';
+export { c as CertificateConfig, d as ConnectionInfo, C as CorsConfig, F as ForwardValidationResult, e as RequestType, b as RouteConfig, l as loadConfig } from './config-DtfpOtWI.js';
 import { IncomingMessage, ServerResponse, IncomingHttpHeaders as IncomingHttpHeaders$1 } from 'node:http';
 import { ServerHttp2Stream, IncomingHttpHeaders } from 'node:http2';
 import 'node:tls';
@@ -33,10 +33,22 @@ declare class ProxyServer {
 }
 /**
  * Create and start a proxy server
+ * Supports config file types: .json, .ts, .js
+ *
+ * Promise chain:
+ * 1. Load configuration from file/env/programmatic
+ * 2. Initialize SSL certificates
+ * 3. Create proxy server instance
+ * 4. Start listening on configured ports
  */
 declare function createProxy(config?: Partial<ServerConfig>): Promise<ProxyServer>;
 /**
  * Create a proxy server with custom handlers
+ *
+ * Promise chain:
+ * 1. Load configuration from file/env/programmatic
+ * 2. Initialize SSL certificates
+ * 3. Create servers with custom handlers
  */
 declare function createCustomProxy(config: Partial<ServerConfig> | undefined, handlers: {
     rest?: Router;