@ezetgalaxy/titan 26.14.1 → 26.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.14.1",
+  "version": "26.15.1",
   "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",
@@ -65,7 +65,8 @@
     "test:all": "vitest run && vitest run --config vitest.config.e2e.ts"
   },
   "dependencies": {
-    "@titanpl/core": "^1.0.1",
+    "@titanpl/core": "latest",
+    "@titanpl/node": "latest",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2",
     "prompts": "^2.4.2"

package/templates/common/Dockerfile

@@ -46,7 +46,7 @@ RUN mkdir -p /app/.ext && \
         rm -rf "/app/.ext/$pkg_name/node_modules"; \
     done
 
-RUN cd server && cargo build --release
+RUN titan build
 
 
 

package/templates/common/app/t.native.d.ts

@@ -1058,6 +1058,8 @@ declare global {
          * @see https://titan-docs-ez.vercel.app/docs/10-extensions — Extensions documentation
          */
         [key: string]: any;
+
+
     }
 
     /**
@@ -1978,6 +1980,64 @@ declare global {
         }
 
     }
+
+    /**
+ * Node-compatible `process` global (Titan Shim).
+ *
+ * This is a lightweight compatibility layer intended
+ * for supporting common Node libraries.
+ *
+ * Internally backed by:
+ * - t.proc
+ * - t.os
+ * - t.time
+ */
+    const process: {
+        /** Process ID */
+        pid: number;
+
+        /** Platform (linux, win32, darwin) */
+        platform: string;
+
+        /** CPU architecture */
+        arch: string;
+
+        /** Node version string (shimmed) */
+        version: string;
+
+        /** Version object */
+        versions: {
+            node: string;
+            titan: string;
+        };
+
+        /** Environment variables */
+        env: Record<string, string | undefined>;
+
+        /** CLI arguments */
+        argv: string[];
+
+        /** Current working directory */
+        cwd(): string;
+
+        /** Uptime in seconds */
+        uptime(): number;
+
+        /** High resolution time */
+        hrtime: {
+            (time?: [number, number]): [number, number];
+            bigint(): bigint;
+        };
+
+        /** Memory usage info */
+        memoryUsage(): Record<string, any>;
+
+        /** No-op event listener (compat only) */
+        on(event: string, listener: (...args: any[]) => void): void;
+
+        /** Exit stub (throws in Titan runtime) */
+        exit(code?: number): never;
+    };
 }
 
 export { };

package/templates/js/package.json

@@ -8,6 +8,7 @@
   },
   "dependencies": {
     "@titanpl/core": "latest",
+    "@titanpl/node": "latest",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2"
   },

package/templates/js/server/Cargo.toml

@@ -10,7 +10,7 @@ reqwest = { version = "0.12.24", features = ["json", "rustls-tls", "gzip", "brot
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 thiserror = "2.0.17"
-tokio = { version = "1.48.0", features = ["rt-multi-thread", "macros", "process"] }
+tokio = { version = "1.48.0", features = ["rt-multi-thread", "macros", "process", "fs"] }
 tower-http = { version = "0.6.7", features = ["cors"] }
 tracing = "0.1.43"
 tracing-subscriber = "0.3.22"

package/templates/js/server/src/action_management.rs

@@ -1,159 +1,175 @@
-
-use std::collections::HashMap;
-use std::env;
-use std::path::{Path, PathBuf};
-use serde::Deserialize;
-use serde_json::Value;
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct RouteVal {
-    pub r#type: String,
-    #[serde(alias = "target")]
-    pub value: Value,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct DynamicRoute {
-    pub method: String,
-    pub pattern: String,
-    pub action: String,
-}
-
-pub fn resolve_actions_dir() -> PathBuf {
-    if let Ok(override_dir) = env::var("TITAN_ACTIONS_DIR") {
-        return PathBuf::from(override_dir);
-    }
-
-    if Path::new("/app/actions").exists() {
-        return PathBuf::from("/app/actions");
-    }
-
-    if let Ok(exe) = std::env::current_exe() {
-        if let Some(parent) = exe.parent() {
-            if let Some(target_dir) = parent.parent() {
-                if let Some(server_dir) = target_dir.parent() {
-                    let candidate = server_dir.join("src").join("actions");
-                    if candidate.exists() {
-                        return candidate;
-                    }
-                    let candidate2 = server_dir.join("actions");
-                    if candidate2.exists() {
-                        return candidate2;
-                    }
-                }
-            }
-        }
-    }
-
-    PathBuf::from("./src/actions")
-}
-
-pub fn find_actions_dir(project_root: &PathBuf) -> Option<PathBuf> {
-    let candidates = [
-        project_root.join("server").join("src").join("actions"),
-        project_root.join("server").join("actions"),
-        project_root.join("app").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
-}
-
-pub fn match_dynamic_route(
-    method: &str,
-    path: &str,
-    routes: &[DynamicRoute],
-) -> Option<(String, HashMap<String, String>)> {
-    let path_segments: Vec<&str> =
-        path.trim_matches('/').split('/').collect();
-
-    for route in routes {
-        if route.method != method {
-            continue;
-        }
-
-        let pattern_segments: Vec<&str> =
-            route.pattern.trim_matches('/').split('/').collect();
-
-        if pattern_segments.len() != path_segments.len() {
-            continue;
-        }
-
-        let mut params = HashMap::new();
-        let mut matched = true;
-
-        for (pat, val) in pattern_segments.iter().zip(path_segments.iter()) {
-            if pat.starts_with(':') {
-                let inner = &pat[1..];
-
-                let (name, ty) = inner
-                    .split_once('<')
-                    .map(|(n, t)| (n, t.trim_end_matches('>')))
-                    .unwrap_or((inner, "string"));
-
-                let valid = match ty {
-                    "number" => val.parse::<i64>().is_ok(),
-                    "string" => true,
-                    _ => false,
-                };
-
-                if !valid {
-                    matched = false;
-                    break;
-                }
-
-                params.insert(name.to_string(), (*val).to_string());
-            } else if pat != val {
-                matched = false;
-                break;
-            }
-        }
-
-        if matched {
-            return Some((route.action.clone(), params));
-        }
-    }
-
-    None
-}
-
-pub fn scan_actions(root: &PathBuf) -> HashMap<String, PathBuf> {
-    let mut map = HashMap::new();
-    
-    let dir = match find_actions_dir(root) {
-        Some(d) => d,
-        None => {
-            let ad = resolve_actions_dir();
-            if ad.exists() { ad } else { return map; }
-        }
-    };
-
-    if let Ok(entries) = std::fs::read_dir(dir) {
-        for entry in entries.flatten() {
-            let path = entry.path();
-            if !path.is_file() { continue; }
-            
-            let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("");
-            if ext != "js" && ext != "jsbundle" {
-                continue;
-            }
-            
-            let file_stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
-            if file_stem.is_empty() { continue; }
-            
-            map.insert(file_stem.to_string(), path);
-        }
-    }
-    
-    map
-}
+//! Action Management and Dynamic Routing
+//!
+//! Handles resolution of action directories, scanning for available actions,
+//! and matching dynamic routes (e.g. `/users/:id`).
+
+use std::collections::HashMap;
+use std::env;
+use std::path::{Path, PathBuf};
+use serde::Deserialize;
+use serde_json::Value;
+
+/// Route configuration (loaded from routes.json)
+#[derive(Debug, Deserialize, Clone)]
+pub struct RouteVal {
+    pub r#type: String,
+    #[serde(alias = "target")]
+    pub value: Value,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct DynamicRoute {
+    pub method: String,
+    pub pattern: String,
+    pub action: String,
+}
+
+/// Resolve the directory path where actions are stored.
+pub fn resolve_actions_dir() -> PathBuf {
+    // Respect explicit override first
+    if let Ok(override_dir) = env::var("TITAN_ACTIONS_DIR") {
+        return PathBuf::from(override_dir);
+    }
+
+    // Production container layout
+    if Path::new("/app/actions").exists() {
+        return PathBuf::from("/app/actions");
+    }
+
+    // Try to walk up from the executing binary to discover `<...>/server/src/actions`
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(parent) = exe.parent() {
+            if let Some(target_dir) = parent.parent() {
+                if let Some(server_dir) = target_dir.parent() {
+                    let candidate = server_dir.join("src").join("actions");
+                    if candidate.exists() {
+                        return candidate;
+                    }
+                    let candidate2 = server_dir.join("actions");
+                    if candidate2.exists() {
+                        return candidate2;
+                    }
+                }
+            }
+        }
+    }
+
+    // Fall back to local ./src/actions
+    PathBuf::from("./src/actions")
+}
+
+/// Try to find the directory that contains compiled action bundles.
+pub fn find_actions_dir(project_root: &PathBuf) -> Option<PathBuf> {
+    let candidates = [
+        project_root.join("server").join("src").join("actions"),
+        project_root.join("server").join("actions"),
+        project_root.join("app").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
+}
+
+/// Match a dynamic route against the current request path.
+pub fn match_dynamic_route(
+    method: &str,
+    path: &str,
+    routes: &[DynamicRoute],
+) -> Option<(String, HashMap<String, String>)> {
+    let path_segments: Vec<&str> =
+        path.trim_matches('/').split('/').collect();
+
+    for route in routes {
+        if route.method != method {
+            continue;
+        }
+
+        let pattern_segments: Vec<&str> =
+            route.pattern.trim_matches('/').split('/').collect();
+
+        if pattern_segments.len() != path_segments.len() {
+            continue;
+        }
+
+        let mut params = HashMap::new();
+        let mut matched = true;
+
+        for (pat, val) in pattern_segments.iter().zip(path_segments.iter()) {
+            if pat.starts_with(':') {
+                let inner = &pat[1..];
+
+                let (name, ty) = inner
+                    .split_once('<')
+                    .map(|(n, t)| (n, t.trim_end_matches('>')))
+                    .unwrap_or((inner, "string"));
+
+                let valid = match ty {
+                    "number" => val.parse::<i64>().is_ok(),
+                    "string" => true,
+                    _ => false,
+                };
+
+                if !valid {
+                    matched = false;
+                    break;
+                }
+
+                params.insert(name.to_string(), (*val).to_string());
+            } else if pat != val {
+                matched = false;
+                break;
+            }
+        }
+
+        if matched {
+            return Some((route.action.clone(), params));
+        }
+    }
+
+    None
+}
+
+/// Scan the resolved actions directory and return a map of action names to file paths.
+pub fn scan_actions(root: &PathBuf) -> HashMap<String, PathBuf> {
+    let mut map = HashMap::new();
+    
+    // Locate actions dir - Priority: project root relative paths
+    let dir = match find_actions_dir(root) {
+        Some(d) => d,
+        None => {
+            let ad = resolve_actions_dir();
+            if ad.exists() { ad } else { return map; }
+        }
+    };
+
+    // Scanning actions
+    if let Ok(entries) = std::fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if !path.is_file() { continue; }
+            
+            let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("");
+            if ext != "js" && ext != "jsbundle" {
+                continue;
+            }
+            
+            let file_stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
+            if file_stem.is_empty() { continue; }
+            
+            // Found action
+            map.insert(file_stem.to_string(), path);
+        }
+    }
+    
+    map
+}

package/templates/js/server/src/errors.rs

@@ -1,10 +1,12 @@
-
-use v8::JsError;
-
-pub fn format_js_error(err: JsError, action: &str) -> String {
-    format!(
-        "Action: {}\n{}",
-        action,
-        err.to_string()
-    )
-}
+//! Error handling utilities.
+
+use v8::JsError;
+
+/// A helper to Format v8 Errors
+pub fn format_js_error(err: JsError, action: &str) -> String {
+    format!(
+        "Action: {}\n{}",
+        action,
+        err.to_string()
+    )
+}