npm - @ezetgalaxy/titan - Versions diffs - 26.7.1 → 26.7.4 - Mend

@ezetgalaxy/titan 26.7.1 → 26.7.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 (11) hide show

package/README.md +4 -2
package/package.json +1 -1
package/templates/Dockerfile +17 -4
package/templates/server/src/extensions.rs +433 -216
package/templates/server/src/main.rs +134 -68
package/titanpl-sdk/README.md +14 -6
package/titanpl-sdk/assets/titanpl-sdk.png +0 -0
package/titanpl-sdk/package.json +2 -1
package/titanpl-sdk/templates/Dockerfile +17 -4
package/titanpl-sdk/templates/server/src/extensions.rs +423 -218
package/titanpl-sdk/templates/server/src/main.rs +134 -68

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

@@ -1,28 +1,27 @@
-use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
 use anyhow::Result;
 use axum::{
-    body::{to_bytes, Body},
+    Router,
+    body::{Body, to_bytes},
     extract::State,
     http::{Request, StatusCode},
     response::{IntoResponse, Json},
     routing::any,
-    Router,
 };
 use serde_json::Value;
-use tokio::net::TcpListener;
 use std::time::Instant;
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+use tokio::net::TcpListener;
 mod utils;
-mod extensions;
 mod action_management;
+mod extensions;
-use utils::{blue, white, yellow, green, gray, red};
-use extensions::{init_v8, inject_extensions};
 use action_management::{
-    resolve_actions_dir, find_actions_dir, match_dynamic_route,
-    DynamicRoute, RouteVal
+    DynamicRoute, RouteVal, find_actions_dir, match_dynamic_route, resolve_actions_dir,
 };
+use extensions::{init_v8, inject_extensions};
+use utils::{blue, gray, green, red, white, yellow};
 #[derive(Clone)]
 struct AppState {
@@ -45,7 +44,6 @@ async fn dynamic_handler_inner(
     State(state): State<AppState>,
     req: Request<Body>,
 ) -> impl IntoResponse {
     // ---------------------------
     // BASIC REQUEST INFO
     // ---------------------------
@@ -70,10 +68,7 @@ async fn dynamic_handler_inner(
             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()
         })
@@ -83,7 +78,7 @@ async fn dynamic_handler_inner(
     // HEADERS & BODY
     // ---------------------------
     let (parts, body) = req.into_parts();
     let headers = parts
         .headers
         .iter()
@@ -92,9 +87,7 @@ async fn dynamic_handler_inner(
     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();
@@ -119,18 +112,32 @@ 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);
@@ -142,7 +149,13 @@ 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();
         }
     };
@@ -151,7 +164,8 @@ async fn dynamic_handler_inner(
     // LOAD ACTION
     // ---------------------------
     let resolved = resolve_actions_dir();
-    let actions_dir = resolved.exists()
+    let actions_dir = resolved
+        .exists()
         .then(|| resolved)
         .or_else(|| find_actions_dir(&state.project_root))
         .unwrap();
@@ -164,17 +178,24 @@ async fn dynamic_handler_inner(
         }
     }
-    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()
-        }
-    };
+    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(),
+        };
     // ---------------------------
     // EXECUTE IN V8
     // ---------------------------
-    let env_json = std::env::vars().map(|(k, v)| (k, Value::String(v))).collect::<serde_json::Map<_, _>>();
+    let env_json = std::env::vars()
+        .map(|(k, v)| (k, Value::String(v)))
+        .collect::<serde_json::Map<_, _>>();
     let injected = format!(
         r#"
@@ -215,43 +236,42 @@ async fn dynamic_handler_inner(
     // 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" });
-             }
+            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
@@ -259,37 +279,59 @@ async fn dynamic_handler_inner(
                 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" })
+                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"}));
+    })
+    .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(&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))
+        ),
         _ => {}
     }
     Json(result_json).into_response()
 }
 // Entrypoint ---------------------------------------------------------------
 #[tokio::main]
@@ -304,28 +346,22 @@ 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();
+    let dynamic_routes: Vec<DynamicRoute> =
+        serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
-    // 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
-    };
+    // Identify project root (where .ext or node_modules lives)
+    let project_root = resolve_project_root();
     let state = AppState {
         routes: Arc::new(map),
         dynamic_routes: Arc::new(dynamic_routes),
         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);
@@ -338,8 +374,38 @@ async fn main() -> Result<()> {
     println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
     println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
     println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
-    println!("\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}", port);
+    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("."))
+}