npm - @ezetgalaxy/titan - Versions diffs - 26.12.3 → 26.12.4 - Mend

@ezetgalaxy/titan 26.12.3 → 26.12.4

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 (5) hide show

package/package.json +1 -1
package/templates/js/server/src/main.rs +204 -154
package/templates/ts/server/src/main.rs +204 -154
package/titanpl-sdk/package.json +1 -1
package/titanpl-sdk/templates/server/src/main.rs +204 -154

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.12.3",
+  "version": "26.12.4",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/js/server/src/main.rs CHANGED Viewed

@@ -1,35 +1,34 @@
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
 use anyhow::Result;
 use axum::{
-    Router,
-    body::{Body, to_bytes},
+    body::{to_bytes, Body},
     extract::State,
     http::{Request, StatusCode},
     response::{IntoResponse, Json},
     routing::any,
+    Router,
 };
 use serde_json::Value;
-use std::time::Instant;
-use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
 use tokio::net::TcpListener;
-use smallvec::SmallVec;
+use std::time::Instant;
 mod utils;
-mod action_management;
 mod extensions;
-mod runtime;
+mod action_management;
+use utils::{blue, white, yellow, green, gray, red};
+use extensions::{init_v8, inject_extensions};
 use action_management::{
-    DynamicRoute, RouteVal, match_dynamic_route,
+    resolve_actions_dir, find_actions_dir, match_dynamic_route,
+    DynamicRoute, RouteVal
 };
-use runtime::RuntimeManager;
-use utils::{blue, gray, green, red, white, yellow};
 #[derive(Clone)]
 struct AppState {
     routes: Arc<HashMap<String, RouteVal>>,
     dynamic_routes: Arc<Vec<DynamicRoute>>,
-    runtime: Arc<RuntimeManager>,
+    project_root: PathBuf,
 }
 // Root/dynamic handlers -----------------------------------------------------
@@ -46,6 +45,7 @@ async fn dynamic_handler_inner(
     State(state): State<AppState>,
     req: Request<Body>,
 ) -> impl IntoResponse {
     // ---------------------------
     // BASIC REQUEST INFO
     // ---------------------------
@@ -63,35 +63,45 @@ async fn dynamic_handler_inner(
     // ---------------------------
     // QUERY PARSING
     // ---------------------------
-    let query_pairs: Vec<(String, String)> = req
+    let query: HashMap<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()))
+                    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
+    let headers = parts
         .headers
         .iter()
         .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
-        .collect();
+        .collect::<HashMap<String, String>>();
     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(),
+        Err(_) => {
+            return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response()
+        }
+    };
+    let body_str = String::from_utf8_lossy(&body_bytes).to_string();
+    let body_json: Value = if body_str.is_empty() {
+        Value::Null
+    } else {
+        serde_json::from_str(&body_str).unwrap_or(Value::String(body_str))
     };
     // ---------------------------
@@ -109,32 +119,18 @@ async fn dynamic_handler_inner(
             action_name = Some(name);
         } else if route.r#type == "json" {
             let elapsed = start.elapsed();
-            println!(
-                "{} {} {} {}",
-                blue("[Titan]"),
-                white(&format!("{} {}", method, path)),
-                white("→ json"),
-                gray(&format!("in {:.2?}", elapsed))
-            );
+            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ json"), gray(&format!("in {:.2?}", elapsed)));
             return Json(route.value.clone()).into_response();
         } else if let Some(s) = route.value.as_str() {
             let elapsed = start.elapsed();
-            println!(
-                "{} {} {} {}",
-                blue("[Titan]"),
-                white(&format!("{} {}", method, path)),
-                white("→ reply"),
-                gray(&format!("in {:.2?}", elapsed))
-            );
+            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ reply"), gray(&format!("in {:.2?}", elapsed)));
             return s.to_string().into_response();
         }
     }
     // Dynamic route
     if action_name.is_none() {
-        if let Some((action, p)) =
-            match_dynamic_route(&method, &path, state.dynamic_routes.as_slice())
-        {
+        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);
@@ -146,102 +142,179 @@ async fn dynamic_handler_inner(
         Some(a) => a,
         None => {
             let elapsed = start.elapsed();
-            println!(
-                "{} {} {} {}",
-                blue("[Titan]"),
-                white(&format!("{} {}", method, path)),
-                white("→ 404"),
-                gray(&format!("in {:.2?}", elapsed))
-            );
+            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ 404"), gray(&format!("in {:.2?}", elapsed)));
             return (StatusCode::NOT_FOUND, "Not Found").into_response();
         }
     };
     // ---------------------------
-    // EXECUTE IN V8 (WORKER POOL)
+    // LOAD ACTION
     // ---------------------------
-    // OPTIMIZATION: Zero-Copy & Stack Allocation
-    // 1. Headers/Params are collected into `SmallVec` (stack allocated if small).
-    // 2. Body is passed as `Bytes` (ref-counted pointer), not copied.
-    // 3. No JSON serialization happens here anymore. This saves ~60% CPU vs previous version.
-    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();
-    // Pass raw bytes to worker if not empty
-    let body_arg = if !body_bytes.is_empty() {
-        Some(body_bytes)
-    } else {
-        None
+    let resolved = resolve_actions_dir();
+    let actions_dir = resolved.exists()
+        .then(|| resolved)
+        .or_else(|| find_actions_dir(&state.project_root))
+        .unwrap();
+    let mut action_path = actions_dir.join(format!("{}.jsbundle", action_name));
+    if !action_path.exists() {
+        let js_path = actions_dir.join(format!("{}.js", action_name));
+        if js_path.exists() {
+            action_path = js_path;
+        }
+    }
+    let js_code = match fs::read_to_string(&action_path) {
+        Ok(c) => c,
+        Err(_) => {
+             return (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Action bundle not found", "action": action_name}))).into_response()
+        }
     };
-    // Dispatch to the optimized RuntimeManager
-    // This sends a pointer-sized message through the ring buffer, triggering
-    // the V8 thread to wake up and process the request immediately.
-    let result_json = state
-        .runtime
-        .execute(
-            action_name,
-            method.clone(),
-            path.clone(),
-            body_arg,
-            headers_vec,
-            params_vec,
-            query_vec
-        )
-        .await
-        .unwrap_or_else(|e| serde_json::json!({"error": e}));
+    // ---------------------------
+    // EXECUTE IN V8
+    // ---------------------------
+    let env_json = std::env::vars().map(|(k, v)| (k, Value::String(v))).collect::<serde_json::Map<_, _>>();
+    let injected = format!(
+        r#"
+        globalThis.process = {{ env: {} }};
+        const __titan_req = {{
+            body: {},
+            method: "{}",
+            path: "{}",
+            headers: {},
+            params: {},
+            query: {}
+        }};
+        (function() {{
+            {}
+        }})(); // Run the bundle
+        // Call the action
+        if (typeof globalThis["{}"] === 'function') {{
+            globalThis["{}"](__titan_req);
+        }} else {{
+            throw new Error("Action function '{}' not found in bundle");
+        }}
+        "#,
+        Value::Object(env_json).to_string(),
+        body_json.to_string(),
+        method,
+        path,
+        serde_json::to_string(&headers).unwrap(),
+        serde_json::to_string(&params).unwrap(),
+        serde_json::to_string(&query).unwrap(),
+        js_code,
+        action_name,
+        action_name,
+        action_name
+    );
+    // Run V8 in a blocking task safely?
+    // Axum handlers are async. V8 operations should be blocking.
+    // We can use `task::spawn_blocking`.
+    let root = state.project_root.clone();
+    let action_name_for_v8 = action_name.clone();
+    let result_json: Value = tokio::task::spawn_blocking(move || {
+        let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+        let handle_scope = &mut v8::HandleScope::new(isolate);
+        let context = v8::Context::new(handle_scope, v8::ContextOptions::default());
+        let scope = &mut v8::ContextScope::new(handle_scope, context);
+        let global = context.global(scope);
+        // Inject extensions (t.read, etc)
+        inject_extensions(scope, global);
+        // Set metadata globals
+        // Set metadata globals
+        let root_str = v8::String::new(scope, root.to_str().unwrap_or(".")).unwrap();
+        let root_key = v8::String::new(scope, "__titan_root").unwrap();
+        global.set(scope, root_key.into(), root_str.into());
+        let action_str = v8::String::new(scope, &action_name_for_v8).unwrap();
+        let action_key = v8::String::new(scope, "__titan_action").unwrap();
+        global.set(scope, action_key.into(), action_str.into());
+        let source = v8::String::new(scope, &injected).unwrap();
+        let try_catch = &mut v8::TryCatch::new(scope);
+        let script = match v8::Script::compile(try_catch, source, None) {
+             Some(s) => s,
+             None => {
+                 let err = try_catch.message().unwrap();
+                 let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
+                 return serde_json::json!({ "error": msg, "phase": "compile" });
+             }
+        };
+        let result = script.run(try_catch);
+        match result {
+            Some(val) => {
+                // Convert v8 Value to Serde JSON
+                // Minimal impl: stringify
+                let json_obj = v8::json::stringify(try_catch, val).unwrap();
+                let json_str = json_obj.to_rust_string_lossy(try_catch);
+                serde_json::from_str(&json_str).unwrap_or(Value::Null)
+            },
+            None => {
+                 let err = try_catch.message().unwrap();
+                 let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
+                 serde_json::json!({ "error": msg, "phase": "execution" })
+            }
+        }
+    }).await.unwrap_or(serde_json::json!({"error": "V8 task failed"}));
     // ---------------------------
     // FINAL LOG
     // ---------------------------
     let elapsed = start.elapsed();
     // Check for errors in result
     if let Some(err) = result_json.get("error") {
-        println!(
-            "{} {} {} {}",
-            blue("[Titan]"),
-            red(&format!("{} {}", method, path)),
-            red("→ error"),
-            gray(&format!("in {:.2?}", elapsed))
-        );
-         println!(
-            "{} {} {} {}",
-            blue("[Titan]"),
-            red("Action Error:"),
-            red(err.as_str().unwrap_or("Unknown")),
-            gray(&format!("in {:.2?}", elapsed))
-        );
+        println!("{} {} {} {}", blue("[Titan]"), red(&format!("{} {}", method, path)), red("→ error"), gray(&format!("in {:.2?}", elapsed)));
+        println!("{}", red(err.as_str().unwrap_or("Unknown")));
         return (StatusCode::INTERNAL_SERVER_ERROR, Json(result_json)).into_response();
     }
     match route_kind {
-        "dynamic" => println!(
-            "{} {} {} {} {} {}",
-            blue("[Titan]"),
-            green(&format!("{} {}", method, path)),
-            white("→"),
-            green(&route_label),
-            white("(dynamic)"),
-            gray(&format!("in {:.2?}", elapsed))
-        ),
-        "exact" => println!(
-            "{} {} {} {} {}",
-            blue("[Titan]"),
-            white(&format!("{} {}", method, path)),
-            white("→"),
-            yellow(&route_label),
-            gray(&format!("in {:.2?}", elapsed))
-        ),
+        "dynamic" => println!("{} {} {} {} {} {}", blue("[Titan]"), green(&format!("{} {}", method, path)), white("→"), green(&route_label), white("(dynamic)"), gray(&format!("in {:.2?}", elapsed))),
+        "exact" => println!("{} {} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→"), yellow(&route_label), gray(&format!("in {:.2?}", elapsed))),
         _ => {}
     }
+    // Check for advanced response object from t.response defined in index.js
+    if result_json.get("_isResponse").and_then(|v| v.as_bool()).unwrap_or(false) {
+        let status_code = result_json.get("status")
+            .and_then(|v| v.as_u64())
+            .unwrap_or(200) as u16;
+        let status = StatusCode::from_u16(status_code).unwrap_or(StatusCode::OK);
+        let mut response_builder = axum::response::Response::builder()
+            .status(status);
+        // Add Headers
+        if let Some(headers) = result_json.get("headers").and_then(|v| v.as_object()) {
+             for (k, v) in headers {
+                 if let Some(val_str) = v.as_str() {
+                     response_builder = response_builder.header(k, val_str);
+                 }
+             }
+        }
+        // Body
+        let body = result_json.get("body")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_string();
+        return response_builder.body(Body::from(body)).unwrap().into_response();
+    }
     Json(result_json).into_response()
 }
@@ -251,6 +324,7 @@ async fn dynamic_handler_inner(
 #[tokio::main]
 async fn main() -> Result<()> {
     dotenvy::dotenv().ok();
+    init_v8(); // Init platform once
     // Load routes.json
     let raw = fs::read_to_string("./routes.json").unwrap_or_else(|_| "{}".to_string());
@@ -259,66 +333,42 @@ async fn main() -> Result<()> {
     let port = json["__config"]["port"].as_u64().unwrap_or(3000);
     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();
-    // Identify project root (where .ext or node_modules lives)
-    let project_root = resolve_project_root();
+    let dynamic_routes: Vec<DynamicRoute> = serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
-    // Load extensions (Load definitions globally)
-    extensions::load_project_extensions(project_root.clone());
-    // Initialize Runtime Manager (Worker Pool)
-    let threads = num_cpus::get() * 4;
-    let runtime_manager = Arc::new(RuntimeManager::new(project_root.clone(), threads));
+    // Project root — heuristics
+    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    // Ensure we find the 'app' directory as sibling if running from 'server'
+    let project_root = if cwd.join("../app").exists() {
+        cwd.join("../app")
+    } else {
+        cwd
+    };
     let state = AppState {
         routes: Arc::new(map),
         dynamic_routes: Arc::new(dynamic_routes),
-        runtime: runtime_manager,
+        project_root: project_root.clone(),
     };
+    // Load extensions
+    extensions::load_project_extensions(project_root.clone());
     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:{}",
-        port
-    );
+    println!("\n\x1b[38;5;208m████████╗██╗████████╗ █████╗ ███╗   ██╗");
+    println!("╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║");
+    println!("   ██║   ██║   ██║   ███████║██╔██╗ ██║");
+    println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
+    println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
+    println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
+    println!("\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}", port);
     axum::serve(listener, app).await?;
     Ok(())
 }
-fn resolve_project_root() -> PathBuf {
-    // 1. Check CWD (preferred for local dev/tooling)
-    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;
-        }
-    }
-    // 2. Check executable persistence (Docker / Production)
-    // Walk up from the executable to find .ext or node_modules
-    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();
-        }
-    }
-    // 3. Fallback to CWD
-    std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
-}