@ezetgalaxy/titan 25.14.0 → 25.14.4

package/index.js

@@ -187,51 +187,41 @@ function buildProd() {
 
     const root = process.cwd();
     const appJs = path.join(root, "app", "app.js");
-    const bundler = path.join(root, "titan", "bundle.js");
     const serverDir = path.join(root, "server");
-    const builtActionsDir = path.join(root, "server", "actions");
     const actionsOut = path.join(serverDir, "actions");
-    // Ensure app/app.js exists
+
+    // BASIC CHECKS
     if (!fs.existsSync(appJs)) {
         console.log(red("ERROR: app/app.js not found."));
         process.exit(1);
     }
 
-    // Ensure bundler exists
-    if (!fs.existsSync(bundler)) {
-        console.log(red("ERROR: titan/bundle.js not found."));
-        process.exit(1);
-    }
-
-    // 1) Generate routes.json and action_map.json
-    console.log(cyan("→ Generating Titan metadata..."));
+    // ----------------------------------------------------
+    // 1) BUILD METADATA + BUNDLE ACTIONS (ONE TIME ONLY)
+    // ----------------------------------------------------
+    console.log(cyan("→ Building Titan metadata + bundling actions..."));
     execSync("node app/app.js --build", { stdio: "inherit" });
 
-    // 2) Bundle JS actions
-    console.log(cyan("→ Bundling Titan actions..."));
-    execSync("node titan/bundle.js", { stdio: "inherit" });
-
-    // 3) Ensure server/actions exists
-    fs.mkdirSync(actionsOut, { recursive: true });   // FIX: mandatory
-
-    // 4) Copy bundled actions to server/actions
-    if (fs.existsSync(builtActionsDir)) {
-        for (const file of fs.readdirSync(builtActionsDir)) {
-            if (file.endsWith(".jsbundle")) {
-                console.log(cyan(`→ Copying ${file}`));
-                fs.copyFileSync(
-                    path.join(builtActionsDir, file),
-                    path.join(actionsOut, file)
-                );
-            }
-        }
-    } else {
-        console.log(yellow("Warning: No actions bundled."));
+    // ensure actions directory exists
+    fs.mkdirSync(actionsOut, { recursive: true });
+
+    // verify bundled actions exist
+    const bundles = fs.readdirSync(actionsOut).filter(f => f.endsWith(".jsbundle"));
+    if (bundles.length === 0) {
+        console.log(red("ERROR: No actions bundled."));
+        console.log(red("Make sure your DSL outputs to server/actions."));
+        process.exit(1);
     }
 
-    console.log(green("✔ Actions copied to server/actions"));
+    bundles.forEach(file => {
+        console.log(cyan(`→ Found action bundle: ${file}`));
+    });
+
+    console.log(green("✔ Actions ready in server/actions"));
 
-    // 5) Build Rust binary
+    // ----------------------------------------------------
+    // 2) BUILD RUST BINARY
+    // ----------------------------------------------------
     console.log(cyan("→ Building Rust release binary..."));
     execSync("cargo build --release", {
         cwd: serverDir,
@@ -242,6 +232,7 @@ function buildProd() {
 }
 
 
+
 /* START PRODUCTION BINARY */
 function startProd() {
     const isWin = process.platform === "win32";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "25.14.0",
+  "version": "25.14.4",
   "description": "JavaScript backend framework that compiles your JS into a Rust + Axum server.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/server/src/main.rs

@@ -1,4 +1,3 @@
-// server/src/main.rs
 use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
 
 use anyhow::Result;
@@ -11,18 +10,23 @@ use axum::{
     Router,
 };
 
-use boa_engine::{object::ObjectInitializer, Context, JsValue, Source};
-use boa_engine::{js_string, native_function::NativeFunction, property::Attribute};
+use boa_engine::{
+    js_string,
+    native_function::NativeFunction,
+    object::ObjectInitializer,
+    property::Attribute,
+    Context, JsValue, Source,
+};
 
-use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use reqwest::blocking::Client;
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 
 use serde::Deserialize;
 use serde_json::Value;
+
 use tokio::net::TcpListener;
 use tokio::task;
 
-/// Route configuration (loaded from routes.json)
 #[derive(Debug, Deserialize)]
 struct RouteVal {
     r#type: String,
@@ -32,307 +36,239 @@ struct RouteVal {
 #[derive(Clone)]
 struct AppState {
     routes: Arc<HashMap<String, RouteVal>>,
+    /// Project root — used only in dev mode
     project_root: PathBuf,
 }
 
-/// Try to find the directory that contains compiled action bundles.
-///
-/// Checks multiple likely paths to support both dev and production container layouts:
-///  - <project_root>/server/actions
-///  - <project_root>/actions
-///  - <project_root>/../server/actions
-///  - /app/actions
-///  - ./actions
-fn find_actions_dir(project_root: &PathBuf) -> Option<PathBuf> {
-    let candidates = [
-        project_root.join("server").join("actions"),
-        project_root.join("actions"),
-        project_root.join("..").join("server").join("actions"),
-        PathBuf::from("/app").join("actions"),
-        PathBuf::from("actions"),
-    ];
-
-    for p in &candidates {
-        if p.exists() && p.is_dir() {
-            return Some(p.clone());
-        }
-    }
-
-    None
-}
-
-/// Injects a synchronous `t.fetch(url, opts?)` function into the Boa `Context`.
-///
-/// Implementation details:
-///  - Converts JS opts → `serde_json::Value` (owned) using `to_json`.
-///  - Executes reqwest blocking client inside `tokio::task::block_in_place` to avoid blocking async runtime.
-///  - Returns `{ ok: bool, status?: number, body?: string, error?: string }`.
 fn inject_t_fetch(ctx: &mut Context) {
-    // Native function (Boa 0.20) using from_fn_ptr
     let t_fetch_native = NativeFunction::from_fn_ptr(|_this, args, ctx| {
-        // Extract URL (owned string)
         let url = args
             .get(0)
             .and_then(|v| v.to_string(ctx).ok())
             .map(|s| s.to_std_string_escaped())
             .unwrap_or_default();
 
-        // Extract opts -> convert to serde_json::Value (owned)
         let opts_js = args.get(1).cloned().unwrap_or(JsValue::undefined());
-        let opts_json: Value = match opts_js.to_json(ctx) {
-            Ok(v) => v,
-            Err(_) => Value::Object(serde_json::Map::new()),
-        };
+        let opts_json: Value = opts_js.to_json(ctx).unwrap_or(Value::Null);
 
-        // Pull method, body, headers into owned Rust values
         let method = opts_json
             .get("method")
             .and_then(|m| m.as_str())
-            .map(|s| s.to_string())
-            .unwrap_or_else(|| "GET".to_string());
+            .unwrap_or("GET")
+            .to_string();
 
-        let body_opt = match opts_json.get("body") {
-            Some(Value::String(s)) => Some(s.clone()),
-            Some(other) => Some(other.to_string()),
-            None => None,
-        };
+        let body_opt = opts_json.get("body").cloned();
 
-        // headers as Vec<(String,String)>
-        let mut header_pairs: Vec<(String, String)> = Vec::new();
+        let mut headers = HeaderMap::new();
         if let Some(Value::Object(map)) = opts_json.get("headers") {
-            for (k, v) in map.iter() {
-                let v_str = match v {
-                    Value::String(s) => s.clone(),
-                    other => other.to_string(),
-                };
-                header_pairs.push((k.clone(), v_str));
+            for (k, v) in map {
+                if let Ok(name) = HeaderName::from_bytes(k.as_bytes()) {
+                    if let Ok(val) = HeaderValue::from_str(&v.to_string()) {
+                        headers.insert(name, val);
+                    }
+                }
             }
         }
 
-        // Perform the blocking HTTP request inside block_in_place to avoid runtime panic
-        let out_json = task::block_in_place(move || {
+        let out = task::block_in_place(move || {
             let client = Client::new();
+            let mut req = client.request(method.parse().unwrap(), &url);
 
-            let method_parsed = method.parse().unwrap_or(reqwest::Method::GET);
-            let mut req = client.request(method_parsed, &url);
-
-            if !header_pairs.is_empty() {
-                let mut headers = HeaderMap::new();
-                for (k, v) in header_pairs.into_iter() {
-                    if let (Ok(name), Ok(val)) =
-                        (HeaderName::from_bytes(k.as_bytes()), HeaderValue::from_str(&v))
-                    {
-                        headers.insert(name, val);
-                    }
-                }
-                req = req.headers(headers);
-            }
+            req = req.headers(headers);
 
             if let Some(body) = body_opt {
-                req = req.body(body);
+                req = req.body(body.to_string());
             }
 
             match req.send() {
                 Ok(resp) => {
                     let status = resp.status().as_u16();
                     let text = resp.text().unwrap_or_default();
-                    serde_json::json!({
-                        "ok": true,
-                        "status": status,
-                        "body": text
-                    })
+                    serde_json::json!({ "ok": true, "status": status, "body": text })
                 }
-                Err(e) => serde_json::json!({
-                    "ok": false,
-                    "error": e.to_string()
-                }),
+                Err(e) => serde_json::json!({ "ok": false, "error": e.to_string() }),
             }
         });
 
-        // Convert serde_json::Value -> JsValue
-        Ok(JsValue::from_json(&out_json, ctx).unwrap_or(JsValue::undefined()))
+        Ok(JsValue::from_json(&out, ctx).unwrap())
     });
 
-    // Convert native function to JS function object (requires Realm)
     let realm = ctx.realm();
     let t_fetch_js_fn = t_fetch_native.to_js_function(realm);
 
-    // Build `t` object with `.fetch`
     let t_obj = ObjectInitializer::new(ctx)
         .property(js_string!("fetch"), t_fetch_js_fn, Attribute::all())
         .build();
 
     ctx.global_object()
         .set(js_string!("t"), JsValue::from(t_obj), false, ctx)
-        .expect("set global t");
+        .unwrap();
 }
 
-// Root/dynamic handlers -----------------------------------------------------
-
-async fn root_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
-    dynamic_handler_inner(state, req).await
+/// DEV: actions inside project/server/actions  
+/// PROD: actions inside /app/actions
+
+fn detect_project_root() -> PathBuf {
+    let exe = std::env::current_exe().unwrap();
+    let dir = exe.parent().unwrap();         // target/debug
+    let is_release = dir.ends_with("release");
+
+    if is_release {
+        // Production
+        PathBuf::from("/app")
+    } else {
+        // Dev executable location:
+        // <project>/server/target/debug/server.exe
+        dir.parent()              // target
+            .unwrap()
+            .parent()             // server
+            .unwrap()
+            .parent()             // <project>
+            .unwrap()
+            .to_path_buf()
+    }
 }
 
-async fn dynamic_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
-    dynamic_handler_inner(state, req).await
+
+fn resolve_actions_dir() -> PathBuf {
+    let exe = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("."));
+    let exe_dir = exe.parent().unwrap_or(Path::new("/app")).to_path_buf();
+
+    // Detect production if running from Docker binary location
+    let is_prod = exe_dir.to_string_lossy().contains("/app")
+        || exe.file_name().unwrap_or_default() == "titan-server";
+
+    if is_prod {
+        // Final production directory
+        return PathBuf::from("/app/actions");
+    }
+
+    // DEV: exe = <root>/server/target/debug/server(.exe)
+    exe_dir
+        .parent()                 // target
+        .unwrap_or(Path::new("."))
+        .parent()                 // server
+        .unwrap_or(Path::new("."))
+        .join("actions")
 }
 
-/// Main handler: looks up routes.json and executes action bundles using Boa.
-async fn dynamic_handler_inner(
+
+
+async fn dynamic_handler(
     State(state): State<AppState>,
     req: Request<Body>,
 ) -> impl IntoResponse {
     let method = req.method().as_str().to_uppercase();
-    let path = req.uri().path();
+    let path = req.uri().path().to_string();
     let key = format!("{}:{}", method, path);
 
     let body_bytes = match to_bytes(req.into_body(), usize::MAX).await {
-        Ok(b) => b,
+        Ok(v) => v,
         Err(_) => return (StatusCode::BAD_REQUEST, "Failed to read body").into_response(),
     };
     let body_str = String::from_utf8_lossy(&body_bytes).to_string();
 
-    if let Some(route) = state.routes.get(&key) {
-        match route.r#type.as_str() {
-            "action" => {
-                let action_name = route.value.as_str().unwrap_or("").trim();
-                if action_name.is_empty() {
-                    return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid action name").into_response();
-                }
+    let route = match state.routes.get(&key) {
+        Some(r) => r,
+        None => return (StatusCode::NOT_FOUND, "Not Found").into_response(),
+    };
 
-                // Resolve actions directory robustly
-                let actions_dir = find_actions_dir(&state.project_root);
-                let actions_dir = match actions_dir {
-                    Some(p) => p,
-                    None => {
-                        return (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Actions directory not found (checked multiple locations)"),
-                        )
-                            .into_response();
-                    }
-                };
+    if route.r#type != "action" {
+        if let Some(s) = route.value.as_str() {
+            return s.to_string().into_response();
+        }
+        return Json(route.value.clone()).into_response();
+    }
 
-                let action_path = actions_dir.join(format!("{}.jsbundle", action_name));
+    let action_name = route.value.as_str().unwrap().trim().to_string();
+    if action_name.is_empty() {
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Invalid action name",
+        )
+            .into_response();
+    }
 
-                if !action_path.exists() {
-                    return (
-                        StatusCode::NOT_FOUND,
-                        format!("Action bundle not found: {:?}", action_path),
-                    )
-                        .into_response();
-                }
+    let actions_dir = resolve_actions_dir(&state.project_root);
+    let action_path = actions_dir.join(format!("{}.jsbundle", action_name));
 
-                let js_code = match fs::read_to_string(&action_path) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        return (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed reading action bundle: {}", e),
-                        )
-                            .into_response();
-                    }
-                };
-
-                // Build env object
-                let mut env_map = serde_json::Map::new();
-                for (k, v) in std::env::vars() {
-                    env_map.insert(k, Value::String(v));
-                }
-                let env_json = Value::Object(env_map);
-
-                // Injected script: sets process.env and __titan_req and invokes action function.
-                let injected = format!(
-                    r#"
-                    globalThis.process = {{ env: {} }};
-                    const __titan_req = {};
-                    {};
-                    {}(__titan_req);
-                    "#,
-                    env_json.to_string(),
-                    body_str,
-                    js_code,
-                    action_name
-                );
-
-                let mut ctx = Context::default();
-                inject_t_fetch(&mut ctx);
-
-                let result = match ctx.eval(Source::from_bytes(&injected)) {
-                    Ok(v) => v,
-                    Err(e) => return Json(json_error(e.to_string())).into_response(),
-                };
-
-                let result_json: Value = match result.to_json(&mut ctx) {
-                    Ok(v) => v,
-                    Err(e) => json_error(e.to_string()),
-                };
-
-                return Json(result_json).into_response();
-            }
+    if !action_path.exists() {
+        return (
+            StatusCode::NOT_FOUND,
+            format!("Action bundle not found: {:?}", action_path),
+        )
+            .into_response();
+    }
 
-            "json" => return Json(route.value.clone()).into_response(),
-            _ => {
-                if let Some(s) = route.value.as_str() {
-                    return s.to_string().into_response();
-                }
-                return route.value.to_string().into_response();
-            }
+    let js_code = match fs::read_to_string(&action_path) {
+        Ok(v) => v,
+        Err(e) => {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Failed reading bundle: {}", e),
+            )
+                .into_response();
         }
+    };
+
+    let mut env_map = serde_json::Map::new();
+    for (k, v) in std::env::vars() {
+        env_map.insert(k, Value::String(v));
     }
+    let env_json = Value::Object(env_map);
+
+    let injected = format!(
+        r#"
+        globalThis.process = {{ env: {} }};
+        const __titan_req = {};
+        {};
+        {}(__titan_req);
+    "#,
+        env_json.to_string(),
+        body_str,
+        js_code,
+        action_name
+    );
 
-    (StatusCode::NOT_FOUND, "Not Found").into_response()
-}
+    let mut ctx = Context::default();
+    inject_t_fetch(&mut ctx);
 
-fn json_error(msg: String) -> Value {
-    serde_json::json!({ "error": msg })
-}
+    let result = match ctx.eval(Source::from_bytes(&injected)) {
+        Ok(v) => v,
+        Err(e) => return Json(serde_json::json!({ "error": e.to_string() })).into_response(),
+    };
 
-// Entrypoint ---------------------------------------------------------------
+    let result_json = result.to_json(&mut ctx).unwrap_or(Value::Null);
+    Json(result_json).into_response()
+}
 
 #[tokio::main]
 async fn main() -> Result<()> {
     dotenvy::dotenv().ok();
 
-    // Load routes.json (expected at runtime root)
-    let raw = fs::read_to_string("./routes.json").unwrap_or_else(|_| "{}".to_string());
+    let raw = fs::read_to_string("./routes.json").unwrap_or("{}".into());
     let json: Value = serde_json::from_str(&raw).unwrap_or_default();
 
     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();
-
-    // Project root — heuristics: try current_dir()
-    let project_root = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-
-    // Debug logging — show where we looked for actions
-    eprintln!("DEBUG runtime cwd: {:?}", std::env::current_dir());
-    eprintln!("DEBUG project_root: {:?}", project_root);
-    eprintln!(
-        "DEBUG found actions dir (if any): {:?}",
-        find_actions_dir(&project_root)
-    );
+    let routes_map: HashMap<String, RouteVal> =
+        serde_json::from_value(json["routes"].clone()).unwrap_or_default();
 
-    let state = AppState {
-        routes: Arc::new(map),
-        project_root,
-    };
+        let project_root = detect_project_root();
+
+let state = AppState {
+    routes: Arc::new(routes_map),
+    project_root,
+};
+
+        
 
     let app = Router::new()
-        .route("/", any(root_route))
-        .fallback(any(dynamic_route))
+        .route("/", any(dynamic_handler))
+        .fallback(any(dynamic_handler))
         .with_state(state);
 
     let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
-
-    // Banner (yellow-orange) and server info
-    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);
+    println!("Titan server running on {}", port);
 
     axum::serve(listener, app).await?;
     Ok(())