npm - titanpl - Versions diffs - 6.0.0 → 7.0.0 - Mend

titanpl 6.0.0 → 7.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (227) hide show

package/titanpl-sdk/templates/server/src/main.rs DELETED Viewed

@@ -1,607 +0,0 @@
-//! Titan HTTP Server (Performance Optimized)
-//!
-//! Key Features:
-//! 1. Fast-path integration: static actions bypass V8 entirely.
-//! 2. Pre-computed route responses: reply routes serve cached bytes.
-//! 3. Benchmark mode: `TITAN_BENCHMARK=1` disables per-request logging & timings.
-//! 4. Early fast-path check BEFORE body/header parsing.
-//! 5. Mimalloc global allocator for faster allocations.
-//! 6. Optimized response construction.
-use anyhow::Result;
-use axum::{
-    Router,
-    body::{Body, to_bytes},
-    extract::State,
-    http::{Request, StatusCode},
-    response::{IntoResponse, Json},
-    routing::any,
-};
-use serde_json::Value;
-use smallvec::SmallVec;
-use std::time::Instant;
-use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
-use tokio::net::TcpListener;
-mod action_management;
-mod extensions;
-mod fast_path;
-mod runtime;
-mod utils;
-use action_management::{DynamicRoute, RouteVal, match_dynamic_route};
-use fast_path::{FastPathRegistry, PrecomputedRoute};
-use runtime::RuntimeManager;
-use utils::{blue, gray, green, red, white, yellow};
-/// Global allocator: mimalloc for ~5-15% better allocation throughput.
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-#[derive(Clone)]
-struct AppState {
-    routes: Arc<HashMap<String, RouteVal>>,
-    dynamic_routes: Arc<Vec<DynamicRoute>>,
-    runtime: Arc<RuntimeManager>,
-    /// Pre-computed responses for static actions (bypass V8)
-    fast_paths: Arc<FastPathRegistry>,
-    /// Pre-serialized responses for reply routes (no re-serialization per request)
-    precomputed: Arc<HashMap<String, PrecomputedRoute>>,
-    /// When true: disable per-request logging and timings injection
-    production_mode: bool,
-}
-async fn root_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
-    handler(state, req).await
-}
-async fn dynamic_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
-    handler(state, req).await
-}
-/// Main request handler — optimized with early fast-path bailout.
-async fn handler(State(state): State<AppState>, req: Request<Body>) -> impl IntoResponse {
-    let method = req.method().as_str().to_uppercase();
-    let path = req.uri().path().to_string();
-    let strict_key = format!("{}:{}", method, path);
-    // Phase 1: Fast-Path Check (before ANY body/header parsing)
-    // This is the critical optimization. For static actions and reply routes,
-    // we return pre-computed bytes without touching the request body, headers,
-    // or V8 runtime. This path costs ~2-5µs vs ~50-100µs for the V8 path.
-    let start = Instant::now();
-    let log_enabled = !state.production_mode;
-    if let Some(route) = state
-        .routes
-        .get(&strict_key)
-        .or_else(|| state.routes.get(&path))
-    {
-        match route.r#type.as_str() {
-            // Precomputed reply routes
-            "json" | "text" => {
-                if let Some(precomputed) = state.precomputed.get(&strict_key) {
-                    if state.production_mode {
-                        // Benchmark mode → zero overhead
-                        return precomputed.to_axum_response();
-                    }
-                    let mut response = precomputed.to_axum_response();
-                    let elapsed = start.elapsed();
-                    response.headers_mut().insert(
-                        "Server-Timing",
-                        format!("reply;dur={:.2}", elapsed.as_secs_f64() * 1000.0)
-                            .parse()
-                            .unwrap_or_else(|_| axum::http::HeaderValue::from_static("")),
-                    );
-                    if log_enabled {
-                        println!(
-                            "{} {} {} {}",
-                            blue("[Titan]"),
-                            green(&format!("{} {}", method, path)),
-                            white("→ reply"),
-                            gray(&format!("in {:.2?}", elapsed))
-                        );
-                    }
-                    return response;
-                }
-                // Fallback (should never happen)
-                if route.r#type == "json" {
-                    return Json(route.value.clone()).into_response();
-                }
-                if let Some(s) = route.value.as_str() {
-                    return s.to_string().into_response();
-                }
-            }
-            // Action routes (Fast path check)
-            "action" => {
-                let action_name = route.value.as_str().unwrap_or("");
-                if let Some(static_resp) = state.fast_paths.get(action_name) {
-                    if state.production_mode {
-                        // Benchmark mode → zero overhead
-                        return static_resp.to_axum_response();
-                    }
-                    let mut response = static_resp.to_axum_response();
-                    let elapsed = start.elapsed();
-                    response.headers_mut().insert(
-                        "Server-Timing",
-                        format!("fastpath;dur={:.2}", elapsed.as_secs_f64() * 1000.0)
-                            .parse()
-                            .unwrap_or_else(|_| axum::http::HeaderValue::from_static("")),
-                    );
-                    if log_enabled {
-                        println!(
-                            "{} {} {} {}",
-                            blue("[Titan]"),
-                            green(&format!("{} {}", method, path)),
-                            white("→ fastpath"),
-                            gray(&format!("in {:.2?}", elapsed))
-                        );
-                    }
-                    return response;
-                }
-                // Not static → continue to dynamic execution
-            }
-            // String reply routes
-            _ => {
-                if let Some(s) = route.value.as_str() {
-                    if state.production_mode {
-                        return s.to_string().into_response();
-                    }
-                    let elapsed = start.elapsed();
-                    if log_enabled {
-                        println!(
-                            "{} {} {} {}",
-                            blue("[Titan]"),
-                            green(&format!("{} {}", method, path)),
-                            white("→ reply"),
-                            gray(&format!("in {:.2?}", elapsed))
-                        );
-                    }
-                    return s.to_string().into_response();
-                }
-            }
-        }
-    }
-    // Phase 2: Dynamic Route Handling (requires body/header parsing)
-    // Only reached for actions that actually need V8 execution.
-    let start = Instant::now(); // restart timing for dynamic path
-    let log_enabled = !state.production_mode;
-    // Query parsing
-    let query_pairs: Vec<(String, String)> = req
-        .uri()
-        .query()
-        .map(|q| {
-            q.split('&')
-                .filter_map(|pair| {
-                    let mut it = pair.splitn(2, '=');
-                    Some((it.next()?.to_string(), it.next().unwrap_or("").to_string()))
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-    let query_map: HashMap<String, String> = query_pairs.into_iter().collect();
-    // Headers & Body
-    let (parts, body) = req.into_parts();
-    let headers_map: HashMap<String, String> = parts
-        .headers
-        .iter()
-        .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
-        .collect();
-    let body_bytes = match to_bytes(body, usize::MAX).await {
-        Ok(b) => b,
-        Err(_) => return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response(),
-    };
-    // Route resolution
-    let mut params: HashMap<String, String> = HashMap::new();
-    let mut action_name: Option<String> = None;
-    let mut route_kind = "none";
-    let mut route_label = String::from("not_found");
-    // Exact route lookup (may find action routes not caught in fast-path phase)
-    let route = state
-        .routes
-        .get(&strict_key)
-        .or_else(|| state.routes.get(&path));
-    if let Some(route) = route {
-        route_kind = "exact";
-        if route.r#type == "action" {
-            let name = route.value.as_str().unwrap_or("unknown").to_string();
-            route_label = name.clone();
-            action_name = Some(name);
-        } else if route.r#type == "json" {
-            // This path shouldn't be reached (handled in Phase 1), but keep as safety
-            if log_enabled {
-                println!(
-                    "{} {} {} {}",
-                    blue("[Titan]"),
-                    white(&format!("{} {}", method, path)),
-                    white("→ json"),
-                    gray(&format!("in {:.2?}", start.elapsed()))
-                );
-            }
-            return Json(route.value.clone()).into_response();
-        } else if let Some(s) = route.value.as_str() {
-            if log_enabled {
-                println!(
-                    "{} {} {} {}",
-                    blue("[Titan]"),
-                    white(&format!("{} {}", method, path)),
-                    white("→ reply"),
-                    gray(&format!("in {:.2?}", start.elapsed()))
-                );
-            }
-            return s.to_string().into_response();
-        }
-    }
-    // Dynamic route matching
-    if action_name.is_none() {
-        if let Some((action, p)) =
-            match_dynamic_route(&method, &path, state.dynamic_routes.as_slice())
-        {
-            route_kind = "dynamic";
-            route_label = action.clone();
-            action_name = Some(action);
-            params = p;
-        }
-    }
-    let action_name = match action_name {
-        Some(a) => a,
-        None => {
-            if log_enabled {
-                println!(
-                    "{} {} {} {}",
-                    blue("[Titan]"),
-                    white(&format!("{} {}", method, path)),
-                    white("→ 404"),
-                    gray(&format!("in {:.2?}", start.elapsed()))
-                );
-            }
-            return (StatusCode::NOT_FOUND, "Not Found").into_response();
-        }
-    };
-    // Phase 3: V8 Execution (dispatch to worker pool)
-    let headers_vec: SmallVec<[(String, String); 8]> = headers_map.into_iter().collect();
-    let params_vec: SmallVec<[(String, String); 4]> = params.into_iter().collect();
-    let query_vec: SmallVec<[(String, String); 4]> = query_map.into_iter().collect();
-    let body_arg = if !body_bytes.is_empty() {
-        Some(body_bytes)
-    } else {
-        None
-    };
-    let (result_json, timings) = state
-        .runtime
-        .execute(
-            action_name.clone(),
-            method.clone(),
-            path.clone(),
-            body_arg,
-            headers_vec,
-            params_vec,
-            query_vec,
-        )
-        .await
-        .unwrap_or_else(|e| (serde_json::json!({"error": e}), vec![]));
-    // Phase 4: Response Construction
-    // NOTE: We intentionally do NOT inject _titanTimings into the JSON body.
-    // This was corrupting benchmark responses (e.g., adding extra fields to
-    // {"message":"Hello, World!"} which fails TechEmpower validation).
-    // Timing info is available via the Server-Timing HTTP header instead.
-    // Error handling
-    if let Some(err) = result_json.get("error") {
-        if log_enabled {
-            let prefix = if !timings.is_empty() {
-                format!("{} {}", blue("[Titan"), blue("Drift]"))
-            } else {
-                blue("[Titan]").to_string()
-            };
-            println!(
-                "{} {} {} {}",
-                prefix,
-                red(&format!("{} {}", method, path)),
-                red("→ error"),
-                gray(&format!("in {:.2?}", start.elapsed()))
-            );
-            println!(
-                "{} {} {}",
-                prefix,
-                red("Action Error:"),
-                red(err.as_str().unwrap_or("Unknown"))
-            );
-        }
-        let response = (StatusCode::INTERNAL_SERVER_ERROR, Json(result_json)).into_response();
-        return response;
-    }
-    // Response object construction
-    let mut response = if let Some(is_resp) = result_json.get("_isResponse") {
-        if is_resp.as_bool().unwrap_or(false) {
-            let status_u16 = result_json
-                .get("status")
-                .and_then(|v| v.as_u64())
-                .unwrap_or(200) as u16;
-            let status = StatusCode::from_u16(status_u16).unwrap_or(StatusCode::OK);
-            let mut builder = axum::http::Response::builder().status(status);
-            if let Some(hmap) = result_json.get("headers").and_then(|v| v.as_object()) {
-                for (k, v) in hmap {
-                    if let Some(vs) = v.as_str() {
-                        builder = builder.header(k, vs);
-                    }
-                }
-            }
-            let mut is_redirect = false;
-            if let Some(location) = result_json.get("redirect") {
-                if let Some(url) = location.as_str() {
-                    let mut final_status_u16 = status.as_u16();
-                    if !(300..400).contains(&final_status_u16) {
-                        final_status_u16 = 302;
-                    }
-                    builder = builder
-                        .status(StatusCode::from_u16(final_status_u16).unwrap_or(StatusCode::FOUND))
-                        .header("Location", url);
-                    is_redirect = true;
-                }
-            }
-            let body_text = if is_redirect {
-                "".to_string()
-            } else {
-                match result_json.get("body") {
-                    Some(Value::String(s)) => s.clone(),
-                    Some(v) => v.to_string(),
-                    None => "".to_string(),
-                }
-            };
-            builder.body(Body::from(body_text)).unwrap()
-        } else {
-            Json(result_json).into_response()
-        }
-    } else {
-        Json(result_json).into_response()
-    };
-    // Server-Timing header (only outside benchmark mode)
-    if !state.production_mode && !timings.is_empty() {
-        let server_timing = timings
-            .iter()
-            .enumerate()
-            .map(|(i, (name, duration))| format!("{}_{};dur={:.2}", name, i, duration))
-            .collect::<Vec<_>>()
-            .join(", ");
-        response
-            .headers_mut()
-            .insert("Server-Timing", server_timing.parse().unwrap_or_else(|_| axum::http::HeaderValue::from_static("")));
-    }
-    // Logging
-    if log_enabled {
-        let total_elapsed = start.elapsed();
-        let total_elapsed_ms = total_elapsed.as_secs_f64() * 1000.0;
-        let total_drift_ms: f64 = timings
-            .iter()
-            .filter(|(n, _)| n == "drift" || n == "drift_error")
-            .map(|(_, d)| d)
-            .sum();
-        let compute_ms = (total_elapsed_ms - total_drift_ms).max(0.0);
-        let prefix = if !timings.is_empty() {
-            format!("{} {}", blue("[Titan"), blue("Drift]"))
-        } else {
-            blue("[Titan]").to_string()
-        };
-        let timing_info = if !timings.is_empty() {
-            gray(&format!(
-                "(active: {:.2}ms, drift: {:.2}ms) in {:.2?}",
-                compute_ms, total_drift_ms, total_elapsed
-            ))
-        } else {
-            gray(&format!("in {:.2?}", total_elapsed))
-        };
-        match route_kind {
-            "dynamic" => println!(
-                "{} {} {} {} {} {}",
-                prefix,
-                green(&format!("{} {}", method, path)),
-                white("→"),
-                green(&route_label),
-                white("(dynamic)"),
-                timing_info
-            ),
-            "exact" => println!(
-                "{} {} {} {} {}",
-                prefix,
-                white(&format!("{} {}", method, path)),
-                white("→"),
-                yellow(&route_label),
-                timing_info
-            ),
-            _ => {}
-        }
-    }
-    response
-}
-#[tokio::main]
-async fn main() -> Result<()> {
-    dotenvy::dotenv().ok();
-    // Configuration
-    let production_mode = std::env::var("TITAN_DEV").unwrap_or_default() != "1";
-    let raw = fs::read_to_string("./routes.json").unwrap_or_else(|_| "{}".to_string());
-    let json: Value = serde_json::from_str(&raw).unwrap_or_default();
-    let port = std::env::var("PORT")
-        .ok()
-        .and_then(|p| p.parse::<u64>().ok())
-        .or_else(|| json["__config"]["port"].as_u64())
-        .unwrap_or(3000);
-    let thread_count = json["__config"]["threads"].as_u64();
-    let routes_json = json["routes"].clone();
-    let map: HashMap<String, RouteVal> = serde_json::from_value(routes_json).unwrap_or_default();
-    let dynamic_routes: Vec<DynamicRoute> =
-        serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
-    let project_root = resolve_project_root();
-    // Load extensions
-    extensions::load_project_extensions(project_root.clone());
-    // Build pre-computed route responses
-    let mut precomputed = HashMap::new();
-    for (key, route) in &map {
-        match route.r#type.as_str() {
-            "json" => {
-                precomputed.insert(key.clone(), PrecomputedRoute::from_json(&route.value));
-            }
-            "text" => {
-                if let Some(s) = route.value.as_str() {
-                    precomputed.insert(key.clone(), PrecomputedRoute::from_text(s));
-                }
-            }
-            _ => {}
-        }
-    }
-    if !precomputed.is_empty() {
-        println!(
-            "{} {} reply route(s) pre-computed",
-            blue("[Titan]"),
-            precomputed.len()
-        );
-    }
-    // Build fast-path registry (scan action files for static patterns)
-    let actions_dir = find_actions_dir(&project_root);
-    let fast_paths = FastPathRegistry::build(&actions_dir);
-    // Initialize Runtime Manager (V8 Worker Pool)
-    let threads = match thread_count {
-        Some(t) if t > 0 => t as usize,
-        _ => {
-            let cpus = num_cpus::get();
-            // Optimal for CPU-bound V8 work: 2x cores
-            cpus * 2
-        }
-    };
-    let stack_mb = json["__config"]["stack_mb"].as_u64().unwrap_or(8);
-    let stack_size = (stack_mb as usize) * 1024 * 1024;
-    let runtime_manager = Arc::new(RuntimeManager::new(
-        project_root.clone(),
-        threads,
-        stack_size,
-    ));
-    // Build AppState
-    let state = AppState {
-        routes: Arc::new(map),
-        dynamic_routes: Arc::new(dynamic_routes),
-        runtime: runtime_manager,
-        fast_paths: Arc::new(fast_paths),
-        precomputed: Arc::new(precomputed),
-        production_mode,
-    };
-    // Router
-    let app = Router::new()
-        .route("/", any(root_route))
-        .fallback(any(dynamic_route))
-        .with_state(state);
-    let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
-    println!(
-        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}  \x1b[90m(Threads: {}, Stack: {}MB{})\x1b[0m",
-        port,
-        threads,
-        stack_mb,
-        if production_mode { "" } else { ", Dev Mode" }
-    );
-    axum::serve(listener, app).await?;
-    Ok(())
-}
-fn resolve_project_root() -> PathBuf {
-    if let Ok(cwd) = std::env::current_dir() {
-        if cwd.join("node_modules").exists()
-            || cwd.join("package.json").exists()
-            || cwd.join(".ext").exists()
-        {
-            return cwd;
-        }
-    }
-    if let Ok(exe) = std::env::current_exe() {
-        let mut current = exe.parent();
-        while let Some(dir) = current {
-            if dir.join(".ext").exists() || dir.join("node_modules").exists() {
-                return dir.to_path_buf();
-            }
-            current = dir.parent();
-        }
-    }
-    std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
-}
-/// Find the actions directory for fast-path scanning.
-fn find_actions_dir(root: &PathBuf) -> PathBuf {
-    let candidates = [
-        root.join("server").join("src").join("actions"),
-        root.join("server").join("actions"),
-        root.join("actions"),
-        PathBuf::from("/app").join("actions"),
-    ];
-    for p in &candidates {
-        if p.exists() && p.is_dir() {
-            return p.clone();
-        }
-    }
-    root.join("server").join("src").join("actions")
-}