@nmtjs/proxy 0.15.0-beta.8 → 1.0.0-alpha.0

package/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "neemata-proxy"
-version = "0.1.0"
-edition = "2024"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-napi = { version = "3", features = ["async"] }
-napi-derive = "3.0.0"
-async-trait = "0.1"
-pingora = { version = "0.6", features = ["lb"] }
-pingora-load-balancing = "0.6"
-http = "1.0"
-tokio = { version = "1.48.0", features = ["sync"] }
-url = "2.5.7"
-log = "0.4.28"
-env_logger = "0.11.8"
-
-[build-dependencies]
-napi-build = "2"
-
-[profile.release]
-lto   = true
-strip = "symbols"

package/LICENSE.md

@@ -1,7 +0,0 @@
-Copyright (c) 2025 Denys Ilchyshyn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,9 +0,0 @@
-# NeemataJS - RPC application server for real-time applications (proof of concept)
-
-### Built with following in mind:
-- transport-agnostic (like WebSockets, WebTransport, .etc)
-- format-agnostic (like JSON, MessagePack, BSON, .etc)
-- binary data streaming and event subscriptions
-- contract-based API
-- end-to-end type safety
-- CPU-intensive task execution on separate workers

package/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    napi_build::setup();
-}

package/src/config.rs

@@ -1,199 +0,0 @@
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-use std::{collections::HashMap, time::Duration};
-use url::Url;
-
-#[napi(object)]
-pub struct ApplicationUpstreamConfig {
-    pub url: String,
-    #[napi(ts_type = "'http' | 'websocket'")]
-    pub r#type: String,
-}
-
-#[napi(object)]
-pub struct ApplicationConfig {
-    pub upstreams: Vec<ApplicationUpstreamConfig>,
-    pub sni: Option<String>,
-    pub enable_tls: Option<bool>,
-}
-
-#[napi(object)]
-pub struct ProxyOptions {
-    pub listen: Option<String>,
-    pub tls: Option<bool>,
-    pub threads: Option<u16>,
-    pub health_check_interval: Option<u32>,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub enum UpstreamKind {
-    Http,
-    Websocket,
-}
-
-impl UpstreamKind {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Self::Http => "http",
-            Self::Websocket => "websocket",
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum AppUpstream {
-    Port {
-        secure: bool,
-        #[allow(dead_code)]
-        address: String,
-        port: u16,
-        hostname: String,
-    },
-    Unix {
-        secure: bool,
-        path: String,
-    },
-}
-
-pub struct AppDefinition {
-    pub upstreams: HashMap<UpstreamKind, Vec<AppUpstream>>,
-    pub sni: Option<String>,
-}
-
-pub struct ProxyConfig {
-    pub apps: HashMap<String, AppDefinition>,
-    pub listen: Option<String>,
-    pub threads: Option<u16>,
-    pub tls: bool,
-    pub health_check_interval: Option<Duration>,
-}
-
-impl ProxyConfig {
-    pub fn from_inputs(
-        apps: HashMap<String, ApplicationConfig>,
-        options: Option<ProxyOptions>,
-    ) -> Result<Self> {
-        if apps.is_empty() {
-            return Err(Error::from_reason(
-                "apps map must contain at least one application",
-            ));
-        }
-
-        let mut normalized_apps = HashMap::with_capacity(apps.len());
-        for (name, config) in apps {
-            if config.upstreams.is_empty() {
-                return Err(Error::from_reason(format!(
-                    "application '{name}' must provide at least one upstream"
-                )));
-            }
-
-            let mut upstreams = HashMap::new();
-
-            for upstream in config.upstreams {
-                let trimmed = upstream.url.trim().to_string();
-                if trimmed.is_empty() {
-                    return Err(Error::from_reason(format!(
-                        "upstream URL cannot be empty in application '{name}'"
-                    )));
-                }
-
-                let parsed = Url::parse(&trimmed).map_err(|_| {
-                    Error::from_reason(format!(
-                        "invalid URL '{trimmed}' in upstreams for application '{name}'"
-                    ))
-                })?;
-
-                let secure = match parsed.scheme() {
-                    "https" | "wss" | "https+unix" | "wss+unix" => true,
-                    "http" | "ws" | "http+unix" | "ws+unix" => false,
-                    other => {
-                        return Err(Error::from_reason(format!(
-                            "unsupported URL scheme '{other}' in upstream '{trimmed}'"
-                        )));
-                    }
-                };
-
-                let upstream_type = match upstream.r#type.as_str() {
-                    "http" => UpstreamKind::Http,
-                    "websocket" => UpstreamKind::Websocket,
-                    other => {
-                        return Err(Error::from_reason(format!(
-                            "unsupported upstream type '{other}' for application '{name}'"
-                        )));
-                    }
-                };
-
-                let upstream = if parsed.scheme().ends_with("+unix") {
-                    AppUpstream::Unix {
-                        secure,
-                        path: parsed.path().to_string(),
-                    }
-                } else {
-                    let host = parsed.host_str().ok_or_else(|| {
-                        Error::from_reason(format!(
-                            "missing host in upstream URL '{trimmed}' for application '{name}'"
-                        ))
-                    })?;
-                    let port = parsed.port_or_known_default().ok_or_else(|| {
-                        Error::from_reason(format!(
-                            "missing port in upstream URL '{trimmed}' for application '{name}'"
-                        ))
-                    })?;
-                    AppUpstream::Port {
-                        secure,
-                        address: parsed.to_string(),
-                        port,
-                        hostname: host.to_string(),
-                    }
-                };
-
-                upstreams
-                    .entry(upstream_type)
-                    .or_insert_with(Vec::new)
-                    .push(upstream);
-            }
-
-            if upstreams.is_empty() {
-                return Err(Error::from_reason(format!(
-                    "application '{name}' produced no valid upstreams"
-                )));
-            }
-
-            let definition = AppDefinition {
-                upstreams,
-                sni: config.sni.filter(|value| !value.is_empty()),
-            };
-
-            normalized_apps.insert(name, definition);
-        }
-
-        let options = options.unwrap_or_default();
-
-        let health_check_interval = options
-            .health_check_interval
-            .map(|secs| Duration::from_secs(secs as u64));
-
-        Ok(Self {
-            apps: normalized_apps,
-            listen: options.listen,
-            threads: options.threads,
-            tls: options.tls.unwrap_or(false),
-            health_check_interval,
-        })
-    }
-
-    pub fn listener(&self) -> &str {
-        self.listen.as_deref().unwrap_or("0.0.0.0:6188")
-    }
-}
-
-impl Default for ProxyOptions {
-    fn default() -> Self {
-        Self {
-            listen: None,
-            threads: None,
-            tls: None,
-            health_check_interval: Some(30),
-        }
-    }
-}

package/src/lib.rs

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

package/src/proxy.rs

@@ -1,147 +0,0 @@
-use crate::{
-    config::{ApplicationConfig, ProxyConfig, ProxyOptions},
-    router::{RouterAssembly, build_router},
-};
-use log::{debug, info};
-use napi::Error as NapiError;
-use napi_derive::napi;
-use pingora::{
-    prelude::{Opt, Server, http_proxy_service},
-    server::{RunArgs, ShutdownSignal, ShutdownSignalWatch, configuration::ServerConf},
-};
-use std::{collections::HashMap, sync::Mutex, thread};
-use tokio::sync::oneshot;
-
-#[napi]
-pub struct NeemataProxy {
-    server: Option<Server>,
-    shutdown_tx: Option<oneshot::Sender<ShutdownSignal>>,
-    runner: Option<thread::JoinHandle<()>>,
-}
-
-#[napi]
-impl NeemataProxy {
-    #[napi(constructor)]
-    pub fn new(
-        apps: HashMap<String, ApplicationConfig>,
-        options: Option<ProxyOptions>,
-    ) -> napi::Result<Self> {
-        env_logger::try_init().ok();
-        const DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS: u64 = 1;
-        let config = ProxyConfig::from_inputs(apps, options)?;
-
-        let mut server_conf = ServerConf::default();
-        let server_opts = Opt {
-            daemon: false,
-            ..Default::default()
-        };
-
-        server_conf.grace_period_seconds = Some(DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS - 1);
-        server_conf.graceful_shutdown_timeout_seconds =
-            Some(DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS);
-        server_conf.threads = config.threads.unwrap_or(1) as usize;
-        server_conf.work_stealing = true;
-
-        let mut server = Server::new_with_opt_and_conf(server_opts, server_conf);
-
-        let RouterAssembly {
-            router,
-            background_services,
-        } = build_router(&config)?;
-
-        let mut proxy_service = http_proxy_service(&server.configuration, router);
-
-        if config.tls {
-            // TODO: support TLS options
-            panic!("TLS is not supported yet");
-        } else {
-            proxy_service.add_tcp(config.listener());
-        }
-
-        server.add_service(proxy_service);
-
-        for service in background_services {
-            server.add_service(service);
-        }
-
-        Ok(Self {
-            server: Some(server),
-            shutdown_tx: None,
-            runner: None,
-        })
-    }
-
-    #[napi]
-    pub fn run(&mut self) -> napi::Result<()> {
-        if self.runner.is_some() {
-            return Err(NapiError::from_reason("server already running"));
-        }
-
-        let server = self
-            .server
-            .take()
-            .ok_or_else(|| NapiError::from_reason("server already running"))?;
-
-        let (tx, rx) = oneshot::channel();
-        self.shutdown_tx = Some(tx);
-
-        let handle = thread::spawn(move || {
-            let args = RunArgs {
-                shutdown_signal: Box::new(JsShutdownWatch::new(rx)),
-            };
-            server.run(args);
-        });
-
-        self.runner = Some(handle);
-        Ok(())
-    }
-
-    #[napi]
-    pub fn shutdown(&mut self) -> napi::Result<()> {
-        info!("Shutting down server. Sending shutdown signal...");
-        let tx = self.shutdown_tx.take().unwrap();
-        let _ = tx.send(ShutdownSignal::GracefulTerminate);
-
-        info!("Joining server thread...");
-        let handle = self.runner.take().unwrap();
-        let _ = handle.join();
-        info!("Server shut down successfully.");
-        Ok(())
-    }
-}
-
-struct JsShutdownWatch {
-    receiver: Mutex<Option<oneshot::Receiver<ShutdownSignal>>>,
-}
-
-impl JsShutdownWatch {
-    fn new(receiver: oneshot::Receiver<ShutdownSignal>) -> Self {
-        Self {
-            receiver: Mutex::new(Some(receiver)),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl ShutdownSignalWatch for JsShutdownWatch {
-    async fn recv(&self) -> ShutdownSignal {
-        let receiver = {
-            let mut guard = match self.receiver.lock() {
-                Ok(guard) => guard,
-                Err(poisoned) => poisoned.into_inner(),
-            };
-
-            guard.take()
-        };
-
-        match receiver {
-            Some(rx) => {
-                debug!("Waiting for shutdown signal from JS...");
-                let signal = rx.await.unwrap_or(ShutdownSignal::FastShutdown);
-                info!("Received shutdown signal from JS: {:?}", signal);
-                signal
-            }
-            None => ShutdownSignal::FastShutdown,
-        }
-    }
-}