@robiki/proxy 1.0.2 → 1.0.3

package/dist/{config-CeJ1tf8T.d.ts → config-CCOdQL7F.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 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/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-CCOdQL7F.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-CCOdQL7F.js';
 import { IncomingMessage, ServerResponse, IncomingHttpHeaders as IncomingHttpHeaders$1 } from 'node:http';
 import { ServerHttp2Stream, IncomingHttpHeaders } from 'node:http2';
 import 'node:tls';
@@ -33,6 +33,7 @@ declare class ProxyServer {
 }
 /**
  * Create and start a proxy server
+ * Supports all config file types: .json, .cjs, .ts, .js, .mjs
  */
 declare function createProxy(config?: Partial<ServerConfig>): Promise<ProxyServer>;
 /**

package/dist/index.js

@@ -485,80 +485,59 @@ class ProxyServer {
     return this.config;
   }
 }
-function createProxy(config) {
-  const createProxyInstance = () => {
-    return new ProxyServer(loadConfig(config));
-  };
-  const startProxy = (proxy) => {
-    return proxy.start().then(() => proxy);
-  };
-  return Promise.resolve().then(() => createProxyInstance()).then((proxy) => startProxy(proxy));
+async function createProxy(config) {
+  const proxyConfig = await loadConfig(config);
+  const proxy = new ProxyServer(proxyConfig);
+  await proxy.start();
+  return proxy;
 }
-function createCustomProxy(config, handlers) {
+async 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 }) => {
-    const boundRestHandler = (req, res) => {
-      if (req.url === "/robiki-proxy/health" && req.method === "GET") {
-        res.writeHead(200, { "Content-Type": "text/plain" });
-        res.end("OK");
-        return;
-      }
-      return restAPIProxyHandler(req, res, proxyConfig);
-    };
-    const boundStreamHandler = (stream, headers) => streamAPIProxyHandler(stream, headers, proxyConfig);
-    const boundWebsocketHandler = (req, socket, headers) => websocketAPIProxyHandler(req, socket, headers, proxyConfig);
-    for (const port of ports) {
-      let server;
-      if (ssl) {
-        server = http2(handlers.rest || boundRestHandler, handlers.stream || boundStreamHandler, {
-          ...ssl,
-          port
-        });
-      } else {
-        server = http(handlers.rest || boundRestHandler, { port });
-      }
-      websocket(server, handlers.websocket || boundWebsocketHandler, (info) => proxyConfig.validate(info));
-      servers.push(server);
+  console.log("STARTING CUSTOM PROXY SERVER....");
+  const proxyConfig = await loadConfig(config);
+  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" });
+      res.end("OK");
+      return;
     }
-    return proxyConfig;
-  };
-  const createProxyInstance = (proxyConfig) => {
-    console.log("Custom proxy server started successfully");
-    return {
-      getConfig: () => proxyConfig,
-      start: async () => {
-      },
-      stop: async () => {
-        await Promise.all(
-          servers.map(
-            (server) => new Promise((resolve, reject) => {
-              server.close((err) => {
-                if (err) reject(err);
-                else resolve();
-              });
-            })
-          )
-        );
-      }
-    };
+    return restAPIProxyHandler(req, res, proxyConfig);
   };
-  const handleError = (error) => {
-    console.error("Failed to start custom proxy server:", error);
-    throw error;
+  const boundStreamHandler = (stream, headers) => streamAPIProxyHandler(stream, headers, proxyConfig);
+  const boundWebsocketHandler = (req, socket, headers) => websocketAPIProxyHandler(req, socket, headers, proxyConfig);
+  for (const port of ports) {
+    let server;
+    if (ssl) {
+      server = http2(handlers.rest || boundRestHandler, handlers.stream || boundStreamHandler, {
+        ...ssl,
+        port
+      });
+    } else {
+      server = http(handlers.rest || boundRestHandler, { port });
+    }
+    websocket(server, handlers.websocket || boundWebsocketHandler, (info) => proxyConfig.validate(info));
+    servers.push(server);
+  }
+  console.log("Custom proxy server started successfully");
+  return {
+    getConfig: () => proxyConfig,
+    start: async () => {
+    },
+    stop: async () => {
+      await Promise.all(
+        servers.map(
+          (server) => new Promise((resolve, reject) => {
+            server.close((err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+          })
+        )
+      );
+    }
   };
-  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 +548,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, P as ProxyConfig, b as RouteConfig, S as ServerConfig, l as loadConfig } from '../config-CCOdQL7F.js';
 import 'node:http2';
 import 'node:tls';
 import 'ws';

package/dist/utils/config.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 class ProxyConfig {
@@ -175,16 +175,47 @@ function getConfigFromEnv() {
   }
   return config;
 }
-function getConfigFromFile() {
+function loadTypeScriptConfig(resolvedPath) {
+  try {
+    const { register } = require("tsx/cjs/api");
+    const unregister = register();
+    try {
+      delete require.cache[resolvedPath];
+      const configModule = require(resolvedPath);
+      return configModule.default || configModule;
+    } finally {
+      unregister();
+    }
+  } catch (error) {
+    console.warn("Failed to load TypeScript config file:", error);
+    console.warn("Make sure tsx is installed: npm install tsx or yarn add tsx");
+    return {};
+  }
+}
+async function getConfigFromFile() {
   const configPath = process.env.PROXY_CONFIG || "./proxy.config.json";
   try {
-    const configFile = readFileSync(resolve(configPath), "utf-8");
+    const resolvedPath = resolve(configPath);
+    if (resolvedPath.endsWith(".ts")) {
+      return loadTypeScriptConfig(resolvedPath);
+    }
+    if (resolvedPath.endsWith(".js") || resolvedPath.endsWith(".mjs")) {
+      const fileUrl = `file://${resolvedPath}`;
+      const configModule = await import(fileUrl);
+      return configModule.default || configModule;
+    }
+    if (resolvedPath.endsWith(".cjs")) {
+      delete require.cache[resolvedPath];
+      const configModule = require(resolvedPath);
+      return configModule.default || configModule;
+    }
+    const configFile = readFileSync(resolvedPath, "utf-8");
     return JSON.parse(configFile);
   } catch (error) {
     return {};
   }
 }
-function loadConfig(programmaticConfig) {
+async function loadConfig(programmaticConfig) {
   const defaults = {
     routes: {},
     cors: {
@@ -192,24 +223,10 @@ function loadConfig(programmaticConfig) {
       credentials: true
     }
   };
-  const fileConfig = getConfigFromFile();
+  const fileConfig = await 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 };
+export { ProxyConfig, loadConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robiki/proxy",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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": {

package/dist/config-CQ7zIaQt.d.ts

@@ -1,172 +0,0 @@
-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;
-}
-/**
- * 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, loadConfigFromEnv as g, 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

@@ -1,180 +0,0 @@
-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 };