@robiki/proxy 1.0.2 → 1.0.4

package/dist/index.js

@@ -5,8 +5,8 @@ import { createServer as createServer$1, request } from 'node:https';
 import { constants, createSecureServer, createServer, connect } from 'node:http2';
 import { exec } from 'node:child_process';
 import { WebSocketServer, WebSocket } from 'ws';
-import { loadConfig } from './utils/config.js';
-import 'node:fs';
+import { d as debug, l as loadConfig } from './config-C-0wrirG.js';
+import 'node:fs/promises';
 import 'node:path';
 
 const num = (seed) => {
@@ -224,7 +224,6 @@ function isMediaFile(path) {
   });
 }
 
-const DEBUG$2 = process.env.DEBUG === "true";
 const restAPIProxyHandler = async (req, res, config) => {
   const { target, ssl, remap } = config.getTarget(req.headers.host || req.headers[":authority"]?.toString() || "");
   if (req.httpVersion === "2.0" && ssl) return;
@@ -233,12 +232,12 @@ const restAPIProxyHandler = async (req, res, config) => {
     res.end("Not Found");
     return;
   }
-  if (DEBUG$2) console.log("HTTP1 rest proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, req.headers.host);
+  debug(`HTTP1 rest proxy for ${req.headers.host}`, `${ssl ? "https" : "http"}://${target}${req.url}`);
   if (remap) req.url = remap(req.url || "");
   const requestFn = ssl ? request : request$1;
   const headers = req.httpVersion === "2.0" ? http2HeadersToHttp1Headers(req.headers) : req.headers;
   const method = req.httpVersion === "2.0" ? req.headers[":method"]?.toString() : req.method;
-  if (DEBUG$2) console.log("Proxy Request::", req.url, method, headers);
+  debug(`Proxy Request :: ${req.url} ${method} ::`, headers);
   const proxy = requestFn(
     `${ssl ? "https" : "http"}://${target}${req.url || ""}`,
     {
@@ -263,13 +262,13 @@ const restAPIProxyHandler = async (req, res, config) => {
         }
       });
       proxyRes.on("error", (error) => {
-        if (DEBUG$2) console.error("Proxy response error:", error);
+        debug("Proxy response error:", error);
         if (!res.destroyed) res.destroy(error);
       });
     }
   );
   proxy.on("error", (error) => {
-    if (DEBUG$2) console.error("Proxy request error:", error);
+    debug("Proxy request error:", error);
     if (!res.headersSent) {
       res.writeHead(502, { "Content-Type": "text/plain" });
       res.end("Bad Gateway");
@@ -286,12 +285,11 @@ const restAPIProxyHandler = async (req, res, config) => {
     }
   });
   req.on("error", (error) => {
-    if (DEBUG$2) console.error("Client request error:", error);
+    debug("Client request error:", error);
     if (!proxy.destroyed) proxy.destroy(error);
   });
 };
 
-const DEBUG$1 = process.env.DEBUG === "true";
 const streamAPIProxyHandler = async (stream, headers, config) => {
   const { target, ssl, remap } = config.getTarget(headers[":authority"] || "");
   if (!ssl) return;
@@ -299,14 +297,9 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
     stream.destroy(new Error("Not Found"));
     return;
   }
-  if (DEBUG$1)
-    console.log(
-      "HTTP2 stream proxy",
-      `${ssl ? "https" : "http"}://${target}${headers[":path"]}`,
-      headers[":authority"]
-    );
+  debug(`HTTP2 stream proxy for ${headers[":authority"]}`, `${ssl ? "https" : "http"}://${target}${headers[":path"]}`);
   if (remap) headers[":path"] = remap(headers[":path"] || "");
-  if (DEBUG$1) console.log("Proxy Request::", headers[":path"]);
+  debug("Proxy Request::", headers[":path"]);
   const proxy = connect(`https://${target}${headers[":path"]}`, {
     ...ssl,
     rejectUnauthorized: false
@@ -315,7 +308,7 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
     const request = proxy.request(headers);
     request.on("response", (headerResponse) => {
       if (!stream.writableEnded && !stream.closed && !stream.destroyed) {
-        if (DEBUG$1) console.log("Proxy Response::", headerResponse[":status"], `for ${headers[":path"]}`);
+        debug(`Proxy Response for ${headers[":path"]}::`, headerResponse[":status"]);
         if (headers[":path"] && isMediaFile(headers[":path"])) {
           headerResponse["cache-control"] = `public, max-age=${day()}`;
         }
@@ -342,7 +335,7 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
       if (!stream.closed && !stream.destroyed) stream.close();
     });
     stream.on("error", (error) => {
-      if (DEBUG$1) console.error("HTTP2 stream proxy error:", error);
+      debug("HTTP2 stream proxy error:", error);
       if (!request.destroyed) request.destroy(error);
       if (!proxy.closed) proxy.close();
     });
@@ -360,28 +353,27 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
       if (!stream.closed && !stream.destroyed) stream.close();
     });
     request.on("error", (error) => {
-      if (DEBUG$1) console.error("HTTP2 request proxy error:", error);
+      debug("HTTP2 request proxy error:", error);
       if (!stream.destroyed) stream.destroy(error);
       return !proxy.closed && proxy.close();
     });
     proxy.on("timeout", () => {
-      if (DEBUG$1) console.error("HTTP/2 client timeout");
+      debug("HTTP/2 client timeout");
       if (!stream.destroyed) stream.destroy(new Error("HTTP/2 client timeout"));
     });
   });
   proxy.on("error", (error) => {
-    if (DEBUG$1) console.error("HTTP2 proxy connection error:", error);
+    debug("HTTP2 proxy connection error:", error);
     if (!stream.destroyed) {
       stream.destroy(error);
     }
   });
 };
 
-const DEBUG = process.env.DEBUG === "true";
 const websocketAPIProxyHandler = async (req, socket, headers, config) => {
   const { target, ssl, remap } = config.getTarget(req.headers.host || "");
   if (!target) return socket.close();
-  if (DEBUG) console.log("HTTP2 websocket proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, headers.host);
+  debug(`HTTP2 websocket proxy for ${headers.host}`, `${ssl ? "https" : "http"}://${target}${req.url}`);
   if (remap) req.url = remap(req.url || "");
   const proxy = new WebSocket(
     `${ssl ? "wss" : "ws"}://${target}${req.url || ""}`,
@@ -405,7 +397,7 @@ const websocketAPIProxyHandler = async (req, socket, headers, config) => {
   proxy.on("close", () => socket.close());
   socket.on("close", () => proxy.close());
   proxy.on("error", (error) => {
-    if (DEBUG) console.error("WebSocket proxy error:", error);
+    debug("WebSocket proxy error:", error);
     socket.close();
   });
 };
@@ -485,30 +477,18 @@ class ProxyServer {
     return this.config;
   }
 }
-function createProxy(config) {
-  const createProxyInstance = () => {
-    return new ProxyServer(loadConfig(config));
-  };
-  const startProxy = (proxy) => {
+async function createProxy(config) {
+  return loadConfig(config).then((proxyConfig) => {
+    const proxy = new ProxyServer(proxyConfig);
     return proxy.start().then(() => proxy);
-  };
-  return Promise.resolve().then(() => createProxyInstance()).then((proxy) => startProxy(proxy));
+  });
 }
-function createCustomProxy(config, handlers) {
-  const servers = [];
-  const initializeConfig = () => {
-    const proxyConfig = loadConfig(config);
-    return {
-      ssl: proxyConfig.getSSL(),
-      ports: proxyConfig.getPorts(),
-      proxyConfig
-    };
-  };
-  const logStartup = (cfg) => {
-    console.log("STARTING CUSTOM PROXY SERVER....");
-    return cfg;
-  };
-  const createServers = ({ ssl, ports, proxyConfig }) => {
+async function createCustomProxy(config, handlers) {
+  console.log("STARTING CUSTOM PROXY SERVER....");
+  return loadConfig(config).then((proxyConfig) => {
+    const servers = [];
+    const ssl = proxyConfig.getSSL();
+    const ports = proxyConfig.getPorts();
     const boundRestHandler = (req, res) => {
       if (req.url === "/robiki-proxy/health" && req.method === "GET") {
         res.writeHead(200, { "Content-Type": "text/plain" });
@@ -532,9 +512,6 @@ function createCustomProxy(config, handlers) {
       websocket(server, handlers.websocket || boundWebsocketHandler, (info) => proxyConfig.validate(info));
       servers.push(server);
     }
-    return proxyConfig;
-  };
-  const createProxyInstance = (proxyConfig) => {
     console.log("Custom proxy server started successfully");
     return {
       getConfig: () => proxyConfig,
@@ -553,12 +530,7 @@ function createCustomProxy(config, handlers) {
         );
       }
     };
-  };
-  const handleError = (error) => {
-    console.error("Failed to start custom proxy server:", error);
-    throw error;
-  };
-  return Promise.resolve().then(() => initializeConfig()).then((cfg) => logStartup(cfg)).then((cfg) => createServers(cfg)).then((proxyConfig) => createProxyInstance(proxyConfig)).catch((error) => handleError(error));
+  });
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
   const setupErrorHandlers = () => {
@@ -569,15 +541,15 @@ if (import.meta.url === `file://${process.argv[1]}`) {
       console.log("UNHANDLED REJECTION: ", reason, promise);
     });
   };
-  const startProxyServer = () => {
-    return createProxy();
+  const startProxyServer = async () => {
+    return await createProxy();
   };
   const handleStartupError = (error) => {
     console.error("Failed to start proxy server:", error);
     process.exit(1);
   };
   setupErrorHandlers();
-  Promise.resolve().then(() => startProxyServer()).catch((error) => handleStartupError(error));
+  startProxyServer().catch((error) => handleStartupError(error));
 }
 
 export { ProxyServer, RequestType, createCustomProxy, createProxy, loadConfig, restAPIProxyHandler, streamAPIProxyHandler, websocketAPIProxyHandler };

package/dist/utils/config.d.ts

@@ -1,5 +1,5 @@
 import 'node:http';
-export { c as CertificateConfig, C as CorsConfig, P as ProxyConfig, b as RouteConfig, S as ServerConfig, l as loadConfig, g as loadConfigFromEnv, f as loadConfigFromFile } from '../config-CeJ1tf8T.js';
+export { c as CertificateConfig, C as CorsConfig, L as LoadedSSLConfig, P as ProxyConfig, b as RouteConfig, S as ServerConfig, l as loadConfig } from '../config-DtfpOtWI.js';
 import 'node:http2';
 import 'node:tls';
 import 'ws';

package/dist/utils/config.js

@@ -1,215 +1,3 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-class ProxyConfig {
-  config;
-  sslConfig;
-  constructor(config) {
-    this.config = config;
-    this.initializeSSL();
-  }
-  /**
-   * Initialize SSL configuration
-   */
-  initializeSSL() {
-    if (!this.config.ssl) return;
-    try {
-      const key = this.config.ssl.key.includes("-----BEGIN") ? Buffer.from(this.config.ssl.key) : readFileSync(resolve(this.config.ssl.key));
-      const cert = this.config.ssl.cert.includes("-----BEGIN") ? Buffer.from(this.config.ssl.cert) : readFileSync(resolve(this.config.ssl.cert));
-      const ca = this.config.ssl.ca ? this.config.ssl.ca.includes("-----BEGIN") ? Buffer.from(this.config.ssl.ca) : readFileSync(resolve(this.config.ssl.ca)) : void 0;
-      this.sslConfig = {
-        key,
-        cert,
-        ca,
-        allowHTTP1: this.config.ssl.allowHTTP1 ?? true
-      };
-    } catch (error) {
-      console.error("Failed to load SSL certificates:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get SSL configuration
-   */
-  getSSL() {
-    return this.sslConfig;
-  }
-  /**
-   * Get route configuration for a host
-   */
-  getRoute(host) {
-    if (this.config.routes[host]) {
-      return this.config.routes[host];
-    }
-    const hostWithoutPort = host.split(":")[0];
-    if (this.config.routes[hostWithoutPort]) {
-      return this.config.routes[hostWithoutPort];
-    }
-    for (const [pattern, route] of Object.entries(this.config.routes)) {
-      if (pattern.includes("*")) {
-        const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
-        if (regex.test(host) || regex.test(hostWithoutPort)) {
-          return route;
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Get target for a host
-   */
-  getTarget(host) {
-    const route = this.getRoute(host);
-    if (!route) {
-      return { target: void 0, ssl: void 0, remap: void 0 };
-    }
-    return {
-      target: route.target,
-      ssl: route.ssl ? this.sslConfig : void 0,
-      remap: route.remap
-    };
-  }
-  /**
-   * Get CORS headers for a request
-   */
-  getCorsHeaders(origin, host) {
-    const route = host ? this.getRoute(host) : void 0;
-    const corsConfig = route?.cors || this.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;
-  }
-  /**
-   * Validate a request
-   */
-  async validate(info) {
-    const route = this.getRoute(info.authority);
-    if (route?.validate) return route.validate(info);
-    if (this.config.validate) return this.config.validate(info);
-    return { status: true };
-  }
-  /**
-   * Get ports to listen on
-   */
-  getPorts() {
-    return this.config.ports || [443, 8080, 9229];
-  }
-  /**
-   * Get the full configuration
-   */
-  getConfig() {
-    return this.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() {
-  const config = {};
-  if (process.env.SSL_KEY && process.env.SSL_CERT) {
-    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) {
-    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"
-    };
-  }
-  return config;
-}
-function getConfigFromFile() {
-  const configPath = process.env.PROXY_CONFIG || "./proxy.config.json";
-  try {
-    const configFile = readFileSync(resolve(configPath), "utf-8");
-    return JSON.parse(configFile);
-  } catch (error) {
-    return {};
-  }
-}
-function loadConfig(programmaticConfig) {
-  const defaults = {
-    routes: {},
-    cors: {
-      origin: "*",
-      credentials: true
-    }
-  };
-  const fileConfig = getConfigFromFile();
-  const envConfig = getConfigFromEnv();
-  const merged = deepMerge(defaults, fileConfig, envConfig, programmaticConfig || {});
-  return new ProxyConfig(merged);
-}
-function loadConfigFromFile(path) {
-  try {
-    const configFile = readFileSync(resolve(path), "utf-8");
-    const config = JSON.parse(configFile);
-    return new ProxyConfig(config);
-  } catch (error) {
-    console.error("Failed to load configuration file:", error);
-    throw error;
-  }
-}
-function loadConfigFromEnv() {
-  const config = getConfigFromEnv();
-  return new ProxyConfig(config);
-}
-
-export { ProxyConfig, loadConfig, loadConfigFromEnv, loadConfigFromFile };
+import 'node:fs/promises';
+import 'node:path';
+export { l as loadConfig } from '../config-C-0wrirG.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robiki/proxy",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A flexible HTTP/2 proxy server with WebSocket support, configurable routing, CORS, and validation. Use as npm package or Docker container.",
   "keywords": [
     "proxy",
@@ -32,10 +32,6 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./proxy": {
-      "import": "./dist/proxy.js",
-      "types": "./dist/proxy.d.ts"
-    },
     "./config": {
       "import": "./dist/utils/config.js",
       "types": "./dist/utils/config.d.ts"
@@ -78,6 +74,7 @@
   },
   "dependencies": {
     "@types/ws": "8.18.1",
+    "tsx": "4.19.2",
     "ws": "8.19.0"
   },
   "engines": {