@robiki/proxy 1.0.0

package/dist/utils/config.js

@@ -0,0 +1,226 @@
+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 [443, 8080, 9229];
+  }
+  /**
+   * Get the full configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+}
+let globalConfig;
+function initConfig(config) {
+  globalConfig = new ProxyConfig(config);
+  return globalConfig;
+}
+function getConfig() {
+  if (!globalConfig) {
+    throw new Error("Configuration not initialized. Call initConfig() first.");
+  }
+  return globalConfig;
+}
+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 initConfig(merged);
+}
+function loadConfigFromFile(path) {
+  try {
+    const configFile = readFileSync(resolve(path), "utf-8");
+    const config = JSON.parse(configFile);
+    return initConfig(config);
+  } catch (error) {
+    console.error("Failed to load configuration file:", error);
+    throw error;
+  }
+}
+function loadConfigFromEnv() {
+  const config = getConfigFromEnv();
+  return initConfig(config);
+}
+
+export { ProxyConfig, getConfig, initConfig, loadConfig, loadConfigFromEnv, loadConfigFromFile };

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@robiki/proxy",
+  "version": "1.0.0",
+  "description": "A flexible HTTP/2 proxy server with WebSocket support, configurable routing, CORS, and validation. Use as npm package or Docker container.",
+  "keywords": [
+    "proxy",
+    "http2",
+    "websocket",
+    "reverse-proxy",
+    "docker",
+    "cors",
+    "ssl",
+    "tls",
+    "routing",
+    "middleware"
+  ],
+  "homepage": "https://github.com/robiki-ai/robiki-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/robiki-ai/robiki-proxy/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robiki-ai/robiki-proxy.git"
+  },
+  "license": "MIT",
+  "author": "Robiki sp. z o.o.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "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"
+    }
+  },
+  "bin": {
+    "robiki-proxy": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "pkgroll",
+    "dev": "node --watch src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "test:docker": "make test-docker-full",
+    "test:docker:config": "make test-docker-config",
+    "test:all": "yarn test && yarn test:docker",
+    "prepublishOnly": "yarn build"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.3",
+    "@types/supertest": "6.0.2",
+    "@vitest/coverage-v8": "4.0.16",
+    "@vitest/ui": "2.1.8",
+    "pkgroll": "2.21.4",
+    "supertest": "7.1.4",
+    "typescript": "5.9.3",
+    "vitest": "4.0.16"
+  },
+  "dependencies": {
+    "@types/ws": "8.18.1",
+    "ws": "8.19.0"
+  },
+  "engines": {
+    "node": ">=21.0.0"
+  },
+  "packageManager": "yarn@1.22.22",
+  "publishConfig": {
+    "access": "public"
+  }
+}