@nmtjs/proxy 0.15.0-beta.2 → 0.15.0-beta.20

package/Cargo.lock

@@ -1231,6 +1231,7 @@ dependencies = [
 name = "neemata-proxy"
 version = "0.1.0"
 dependencies = [
+ "arc-swap",
  "async-trait",
  "env_logger",
  "http",
@@ -1241,6 +1242,7 @@ dependencies = [
  "pingora",
  "pingora-load-balancing",
  "tokio",
+ "tokio-util",
  "url",
 ]
 

package/Cargo.toml

@@ -7,13 +7,15 @@ edition = "2024"
 crate-type = ["cdylib"]
 
 [dependencies]
-napi = { version = "3", features = ["async"] }
+napi = { version = "3", features = ["async", "tokio_rt", "napi4"] }
 napi-derive = "3.0.0"
 async-trait = "0.1"
-pingora = { version = "0.6", features = ["lb"] }
+pingora = { version = "0.6", features = ["lb", "proxy"] }
 pingora-load-balancing = "0.6"
 http = "1.0"
-tokio = { version = "1.48.0", features = ["sync"] }
+tokio = { version = "1.48.0", features = ["macros", "net", "rt-multi-thread", "sync", "time"] }
+tokio-util = "0.7"
+arc-swap = "1.7"
 url = "2.5.7"
 log = "0.4.28"
 env_logger = "0.11.8"

package/package.json

@@ -10,6 +10,13 @@
   "dependencies": {
     "@napi-rs/cli": "^3.4.1"
   },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0",
+    "@types/ws": "^8.18.1",
+    "ws": "^8.18.3"
+  },
   "files": [
     "src",
     "build.rs",
@@ -18,13 +25,13 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.2",
+  "version": "0.15.0-beta.20",
   "scripts": {
     "postinstall": "$npm_execpath build",
-    "clean-build": "true",
     "fmt": "cargo fmt",
     "lint": "cargo clippy",
     "build": "$npm_execpath build:debug --release",
-    "build:debug": "napi build --esm --js index.js --platform --output-dir ./dist"
+    "build:debug": "napi build --esm --js index.js --platform --output-dir ./dist",
+    "test": "cargo test && vitest run"
   }
 }

package/src/errors.rs

@@ -0,0 +1,28 @@
+use napi::{Env, Error, Result, Status};
+
+pub mod codes {
+    pub const INVALID_PROXY_OPTIONS: &str = "InvalidProxyOptions";
+    pub const INVALID_APPLICATION_OPTIONS: &str = "InvalidApplicationOptions";
+    pub const UNKNOWN_APPLICATION: &str = "UnknownApplication";
+    pub const ALREADY_STARTED: &str = "AlreadyStarted";
+    pub const LISTEN_BIND_FAILED: &str = "ListenBindFailed";
+    pub const UNSUPPORTED_UPSTREAM_TYPE: &str = "UnsupportedUpstreamType";
+    pub const UPSTREAM_ALREADY_EXISTS: &str = "UpstreamAlreadyExists";
+    pub const UPSTREAM_NOT_FOUND: &str = "UpstreamNotFound";
+}
+
+pub fn type_error(env: &Env, code: &str, msg: impl AsRef<str>) -> Error {
+    let msg = msg.as_ref();
+    let _ = env.throw_type_error(msg, Some(code));
+    Error::new(Status::InvalidArg, msg.to_owned())
+}
+
+pub fn generic_error(env: &Env, code: &str, msg: impl AsRef<str>) -> Error {
+    let msg = msg.as_ref();
+    let _ = env.throw_error(msg, Some(code));
+    Error::new(Status::GenericFailure, msg.to_owned())
+}
+
+pub fn throw_type_error<T>(env: &Env, code: &str, msg: impl AsRef<str>) -> Result<T> {
+    Err(type_error(env, code, msg))
+}

package/src/lb.rs

@@ -0,0 +1,45 @@
+use std::{net::SocketAddr, sync::Arc, time::Duration};
+
+use pingora::lb::{LoadBalancer, selection::RoundRobin};
+use pingora::server::ShutdownWatch;
+use pingora::services::background::BackgroundService;
+use tokio::sync::watch;
+
+use crate::server::ServiceHandle;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[allow(dead_code)]
+pub enum TransportKind {
+    Http1,
+    Http2,
+}
+
+#[allow(dead_code)]
+pub fn build_round_robin_lb(
+    addrs: Vec<SocketAddr>,
+    health_check_frequency: Option<Duration>,
+) -> std::io::Result<Arc<LoadBalancer<RoundRobin>>> {
+    let mut lb = LoadBalancer::<RoundRobin>::try_from_iter(addrs)?;
+    lb.health_check_frequency = health_check_frequency;
+    Ok(Arc::new(lb))
+}
+
+#[allow(dead_code)]
+pub fn spawn_lb_health_task(lb: Arc<LoadBalancer<RoundRobin>>) -> ServiceHandle {
+    let cancel = tokio_util::sync::CancellationToken::new();
+    let cancel_child = cancel.clone();
+
+    let (shutdown_tx, shutdown_rx): (watch::Sender<bool>, ShutdownWatch) = watch::channel(false);
+
+    let task = tokio::spawn(async move {
+        let start_fut = lb.start(shutdown_rx);
+        tokio::select! {
+            _ = start_fut => {}
+            _ = cancel_child.cancelled() => {
+                let _ = shutdown_tx.send(true);
+            }
+        }
+    });
+
+    ServiceHandle { cancel, task }
+}

package/src/lib.rs

@@ -1,8 +1,10 @@
 #![deny(clippy::all)]
 
-mod config;
+mod errors;
+mod lb;
+mod options;
 mod proxy;
 mod router;
+mod server;
 
-pub use config::{ApplicationConfig, ProxyOptions};
-pub use proxy::NeemataProxy;
+pub use proxy::Proxy;

package/src/options.rs

@@ -0,0 +1,178 @@
+use crate::errors;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct ProxyOptions {
+    pub listen: String,
+    pub tls: Option<ListenerTlsOptions>,
+    pub applications: Vec<ApplicationOptions>,
+    /// Health check interval in milliseconds. Defaults to 5000ms (5 seconds).
+    pub health_check_interval_ms: Option<u32>,
+}
+
+#[napi(object)]
+pub struct ListenerTlsOptions {
+    pub cert_path: String,
+    pub key_path: String,
+    pub enable_h2: Option<bool>,
+}
+
+#[napi(object)]
+pub struct ApplicationOptions {
+    pub name: String,
+    pub routing: RoutingOptions,
+    pub sni: Option<String>,
+}
+
+#[napi(object)]
+pub struct RoutingOptions {
+    #[napi(ts_type = " 'subdomain' | 'path' ")]
+    pub r#type: Option<String>,
+    pub name: Option<String>,
+    pub default: Option<bool>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ProxyOptionsParsed {
+    pub listen: String,
+    pub tls: Option<ListenerTlsOptionsParsed>,
+    pub applications: Vec<ApplicationOptionsParsed>,
+    /// Health check interval in milliseconds.
+    pub health_check_interval_ms: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct ListenerTlsOptionsParsed {
+    pub cert_path: String,
+    pub key_path: String,
+    pub enable_h2: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct ApplicationOptionsParsed {
+    pub name: String,
+    pub routing: ApplicationRoutingParsed,
+    pub sni: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub enum ApplicationRoutingParsed {
+    Subdomain { name: String },
+    Path { name: String },
+    Default,
+}
+
+pub fn parse_proxy_options(env: &Env, options: ProxyOptions) -> Result<ProxyOptionsParsed> {
+    let listen = options.listen;
+
+    let tls = options.tls.map(|tls| ListenerTlsOptionsParsed {
+        cert_path: tls.cert_path,
+        key_path: tls.key_path,
+        enable_h2: tls.enable_h2.unwrap_or(false),
+    });
+
+    let mut applications = Vec::with_capacity(options.applications.len());
+    for app in options.applications {
+        applications.push(parse_application_options(env, app)?);
+    }
+
+    validate_applications(env, &applications)?;
+
+    Ok(ProxyOptionsParsed {
+        listen,
+        tls,
+        applications,
+        health_check_interval_ms: options.health_check_interval_ms.unwrap_or(5000),
+    })
+}
+
+fn parse_application_options(
+    env: &Env,
+    app: ApplicationOptions,
+) -> Result<ApplicationOptionsParsed> {
+    let name = app.name;
+    let sni = app.sni;
+    let routing = parse_routing(env, app.routing)?;
+    Ok(ApplicationOptionsParsed { name, routing, sni })
+}
+
+fn parse_routing(env: &Env, routing: RoutingOptions) -> Result<ApplicationRoutingParsed> {
+    if routing.default.unwrap_or(false) {
+        return Ok(ApplicationRoutingParsed::Default);
+    }
+
+    let Some(routing_type) = routing.r#type else {
+        return errors::throw_type_error(
+            env,
+            errors::codes::INVALID_APPLICATION_OPTIONS,
+            "ApplicationOptions.routing.type must be set unless routing.default=true",
+        );
+    };
+    let Some(routing_name) = routing.name else {
+        return errors::throw_type_error(
+            env,
+            errors::codes::INVALID_APPLICATION_OPTIONS,
+            "ApplicationOptions.routing.name must be set unless routing.default=true",
+        );
+    };
+
+    match routing_type.as_str() {
+        "subdomain" => Ok(ApplicationRoutingParsed::Subdomain { name: routing_name }),
+        "path" => Ok(ApplicationRoutingParsed::Path { name: routing_name }),
+        other => errors::throw_type_error(
+            env,
+            errors::codes::INVALID_APPLICATION_OPTIONS,
+            format!(
+                "Unknown routing.type '{other}'. Expected 'subdomain' or 'path', or use routing.default=true"
+            ),
+        ),
+    }
+}
+
+fn validate_applications(env: &Env, applications: &[ApplicationOptionsParsed]) -> Result<()> {
+    let mut default_count = 0usize;
+
+    for app in applications {
+        match &app.routing {
+            ApplicationRoutingParsed::Default => {
+                default_count += 1;
+            }
+            ApplicationRoutingParsed::Subdomain { name } => {
+                if name.is_empty() {
+                    return errors::throw_type_error(
+                        env,
+                        errors::codes::INVALID_APPLICATION_OPTIONS,
+                        "subdomain routing name must be non-empty",
+                    );
+                }
+            }
+            ApplicationRoutingParsed::Path { name } => {
+                if name.is_empty() {
+                    return errors::throw_type_error(
+                        env,
+                        errors::codes::INVALID_APPLICATION_OPTIONS,
+                        "path routing name must be non-empty",
+                    );
+                }
+                if name.contains('/') {
+                    return errors::throw_type_error(
+                        env,
+                        errors::codes::INVALID_APPLICATION_OPTIONS,
+                        "path routing name must not contain '/'",
+                    );
+                }
+            }
+        }
+    }
+
+    if default_count > 1 {
+        return errors::throw_type_error(
+            env,
+            errors::codes::INVALID_APPLICATION_OPTIONS,
+            "At most one application may have routing.default=true",
+        );
+    }
+
+    Ok(())
+}