@ezetgalaxy/titan 26.12.5 → 26.12.7

package/README.md

@@ -14,6 +14,7 @@
 💟 **Titan Planet docs:** https://titan-docs-ez.vercel.app/docs
 🚀 **CLI: `titan` is now the canonical command. `tit` remains supported as an alias.**
 🛡️ **Strict Mode:** Titan now enforces zero type errors before running.
+✅ **For text response from a action file use t.response.text("Hii TitanPl")
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.12.5",
+  "version": "26.12.7",
   "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/extensions/mod.rs

@@ -2,19 +2,19 @@
 pub mod builtin;
 pub mod external;
 
-use v8;
-use std::sync::Once;
-use std::path::PathBuf;
-use std::sync::{Mutex, Arc, OnceLock};
-use std::collections::HashMap;
-use std::fs;
-use dashmap::DashMap;
-use tokio::sync::broadcast;
 use crate::action_management::scan_actions;
+use crate::utils::{blue, gray, green, red};
 use bytes::Bytes;
 use crossbeam::channel::Sender;
+use dashmap::DashMap;
 use serde_json::Value;
-use crate::utils::{blue, red, gray, green};
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Once;
+use std::sync::{Arc, Mutex, OnceLock};
+use tokio::sync::broadcast;
+use v8;
 
 // ----------------------------------------------------------------------------
 // GLOBALS
@@ -66,23 +66,26 @@ pub fn init_v8() {
     });
 }
 
-pub fn init_runtime_worker(root: PathBuf, worker_tx: crossbeam::channel::Sender<crate::runtime::WorkerCommand>) -> TitanRuntime {
+pub fn init_runtime_worker(
+    root: PathBuf,
+    worker_tx: crossbeam::channel::Sender<crate::runtime::WorkerCommand>,
+) -> TitanRuntime {
     init_v8();
-    
+
     // Memory optimization strategy (v8 0.106.0 limitations):
     // - V8 snapshots reduce memory footprint by sharing compiled code
     // - Each isolate still has its own heap, but the snapshot reduces base overhead
     // - For explicit heap limits, use V8 flags: --max-old-space-size=128
-    
+
     let params = v8::CreateParams::default();
     let mut isolate = v8::Isolate::new(params);
-    
+
     let (global_context, actions_map) = {
         let handle_scope = &mut v8::HandleScope::new(&mut 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 Titan Runtime APIs
         inject_extensions(scope, global);
 
@@ -95,19 +98,20 @@ pub fn init_runtime_worker(root: PathBuf, worker_tx: crossbeam::channel::Sender<
         let mut map = HashMap::new();
         let action_files = scan_actions(&root);
         for (name, path) in action_files {
-             if let Ok(code) = fs::read_to_string(&path) {
-                 let wrapped_source = format!("(function() {{ {} }})(); globalThis[\"{}\"];", code, name);
-                 let source_str = v8_str(scope, &wrapped_source);
-                 let try_catch = &mut v8::TryCatch::new(scope);
-                 if let Some(script) = v8::Script::compile(try_catch, source_str, None) {
-                     if let Some(val) = script.run(try_catch) {
-                         if val.is_function() {
-                             let func = v8::Local::<v8::Function>::try_from(val).unwrap();
-                             map.insert(name.clone(), v8::Global::new(try_catch, func));
-                         }
-                     }
-                 }
-             }
+            if let Ok(code) = fs::read_to_string(&path) {
+                let wrapped_source =
+                    format!("(function() {{ {} }})(); globalThis[\"{}\"];", code, name);
+                let source_str = v8_str(scope, &wrapped_source);
+                let try_catch = &mut v8::TryCatch::new(scope);
+                if let Some(script) = v8::Script::compile(try_catch, source_str, None) {
+                    if let Some(val) = script.run(try_catch) {
+                        if val.is_function() {
+                            let func = v8::Local::<v8::Function>::try_from(val).unwrap();
+                            map.insert(name.clone(), v8::Global::new(try_catch, func));
+                        }
+                    }
+                }
+            }
         }
         (v8::Global::new(scope, context), map)
     };
@@ -127,7 +131,9 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
 
     let t_obj = v8::Object::new(scope);
     let t_key = v8_str(scope, "t");
-    global.create_data_property(scope, t_key.into(), t_obj.into()).unwrap();
+    global
+        .create_data_property(scope, t_key.into(), t_obj.into())
+        .unwrap();
 
     // Call individual injectors
     builtin::inject_builtin_extensions(scope, global, t_obj);
@@ -136,31 +142,109 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     global.set(scope, t_key.into(), t_obj.into());
 }
 
+fn v8_to_json<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    value: v8::Local<v8::Value>,
+) -> serde_json::Value {
+    if value.is_null_or_undefined() {
+        return serde_json::Value::Null;
+    }
+
+    // Boolean
+    if value.is_boolean() {
+        return serde_json::Value::Bool(value.boolean_value(scope));
+    }
+
+    // Number
+    if value.is_number() {
+        let n = value.number_value(scope).unwrap_or(0.0);
+        return serde_json::Value::Number(
+            serde_json::Number::from_f64(n).unwrap_or_else(|| serde_json::Number::from(0)),
+        );
+    }
+
+    // String
+    if value.is_string() {
+        let s = value.to_string(scope).unwrap().to_rust_string_lossy(scope);
+        return serde_json::Value::String(s);
+    }
+
+    // Array
+    if value.is_array() {
+        let arr = v8::Local::<v8::Array>::try_from(value).unwrap();
+        let mut list = Vec::with_capacity(arr.length() as usize);
+        for i in 0..arr.length() {
+            let element = arr
+                .get_index(scope, i)
+                .unwrap_or_else(|| v8::null(scope).into());
+            list.push(v8_to_json(scope, element));
+        }
+        return serde_json::Value::Array(list);
+    }
+
+    // Object
+    if value.is_object() {
+        let obj = value.to_object(scope).unwrap();
+
+        let props = obj
+            .get_own_property_names(scope, v8::GetPropertyNamesArgs::default())
+            .unwrap();
+
+        let mut map = serde_json::Map::new();
+
+        for i in 0..props.length() {
+            let key_val = props
+                .get_index(scope, i)
+                .unwrap_or_else(|| v8::null(scope).into());
+
+            let key = key_val
+                .to_string(scope)
+                .unwrap()
+                .to_rust_string_lossy(scope);
+
+            let val = obj
+                .get(scope, key_val.into())
+                .unwrap_or_else(|| v8::null(scope).into());
+
+            map.insert(key, v8_to_json(scope, val));
+        }
+
+        return serde_json::Value::Object(map);
+    }
+
+    serde_json::Value::Null
+}
+
 // ----------------------------------------------------------------------------
 // EXECUTION HELPERS
 // ----------------------------------------------------------------------------
 
 pub fn execute_action_optimized(
     runtime: &mut TitanRuntime,
-    action_name: &str, 
-    req_body: Option<bytes::Bytes>, 
-    req_method: &str, 
-    req_path: &str, 
-    headers: &[(String, String)], 
-    params: &[(String, String)], 
-    query: &[(String, String)]
+    action_name: &str,
+    req_body: Option<bytes::Bytes>,
+    req_method: &str,
+    req_path: &str,
+    headers: &[(String, String)],
+    params: &[(String, String)],
+    query: &[(String, String)],
 ) -> serde_json::Value {
-    let TitanRuntime { isolate, context: global_context, actions: actions_map, .. } = runtime;
+    let TitanRuntime {
+        isolate,
+        context: global_context,
+        actions: actions_map,
+        ..
+    } = runtime;
     let handle_scope = &mut v8::HandleScope::new(isolate);
     let context = v8::Local::new(handle_scope, &*global_context);
     let scope = &mut v8::ContextScope::new(handle_scope, context);
-    
+
     let req_obj = v8::Object::new(scope);
-    
+
     let m_key = v8_str(scope, "method");
     let m_val = v8_str(scope, req_method);
     req_obj.set(scope, m_key.into(), m_val.into());
-    
+
     let p_key = v8_str(scope, "path");
     let p_val = v8_str(scope, req_path);
     req_obj.set(scope, p_key.into(), p_val.into());
@@ -170,33 +254,35 @@ pub fn execute_action_optimized(
         let store = v8::ArrayBuffer::new_backing_store_from_boxed_slice(vec.into_boxed_slice());
         let ab = v8::ArrayBuffer::with_backing_store(scope, &store.make_shared());
         ab.into()
-    } else { v8::null(scope).into() };
+    } else {
+        v8::null(scope).into()
+    };
     let rb_key = v8_str(scope, "rawBody");
     req_obj.set(scope, rb_key.into(), body_val);
 
     let h_obj = v8::Object::new(scope);
-    for (k, v) in headers { 
+    for (k, v) in headers {
         let k_v8 = v8_str(scope, k);
         let v_v8 = v8_str(scope, v);
-        h_obj.set(scope, k_v8.into(), v_v8.into()); 
+        h_obj.set(scope, k_v8.into(), v_v8.into());
     }
     let h_key = v8_str(scope, "headers");
     req_obj.set(scope, h_key.into(), h_obj.into());
 
     let p_obj = v8::Object::new(scope);
-    for (k, v) in params { 
+    for (k, v) in params {
         let k_v8 = v8_str(scope, k);
         let v_v8 = v8_str(scope, v);
-        p_obj.set(scope, k_v8.into(), v_v8.into()); 
+        p_obj.set(scope, k_v8.into(), v_v8.into());
     }
     let params_key = v8_str(scope, "params");
     req_obj.set(scope, params_key.into(), p_obj.into());
 
     let q_obj = v8::Object::new(scope);
-    for (k, v) in query { 
+    for (k, v) in query {
         let k_v8 = v8_str(scope, k);
         let v_v8 = v8_str(scope, v);
-        q_obj.set(scope, k_v8.into(), v_v8.into()); 
+        q_obj.set(scope, k_v8.into(), v_v8.into());
     }
     let q_key = v8_str(scope, "query");
     req_obj.set(scope, q_key.into(), q_obj.into());
@@ -211,12 +297,15 @@ pub fn execute_action_optimized(
         let tr_act_val = v8_str(scope, action_name);
         global.set(scope, tr_act_key.into(), tr_act_val.into());
         let try_catch = &mut v8::TryCatch::new(scope);
+
         if let Some(result) = action_fn.call(try_catch, global.into(), &[req_obj.into()]) {
-             if let Some(json) = v8::json::stringify(try_catch, result) {
-                 return serde_json::from_str(&json.to_rust_string_lossy(try_catch)).unwrap_or(serde_json::Value::Null);
-             }
+            return v8_to_json(try_catch, result);
         }
-        let msg = try_catch.message().map(|m| m.get(try_catch).to_rust_string_lossy(try_catch)).unwrap_or("Unknown error".to_string());
+
+        let msg = try_catch
+            .message()
+            .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
+            .unwrap_or("Unknown error".to_string());
         return serde_json::json!({"error": msg});
     }
     serde_json::json!({"error": format!("Action '{}' not found", action_name)})