@ezetgalaxy/titan 26.7.5 → 26.8.2

package/templates/rust/server/Cargo.toml

@@ -0,0 +1,39 @@
+
+[package]
+name = "titan-server"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+axum = "0.8.7"
+dotenv = "0.15.0"
+reqwest = { version = "0.12.24", features = ["json", "rustls-tls", "gzip", "brotli", "blocking"] }
+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"] }
+tower-http = { version = "0.6.7", features = ["cors"] }
+tracing = "0.1.43"
+tracing-subscriber = "0.3.22"
+anyhow = "1"
+v8 = "0.106.0"
+dotenvy = "0.15"
+base64 = "0.21"
+regex = "1.10"
+bcrypt = "0.15"
+jsonwebtoken = "9"
+postgres = { version = "0.19", features = ["with-serde_json-1"] }
+libloading = "0.8"
+walkdir = "2"
+
+[profile.dev]
+opt-level = 0
+debug = 1
+incremental = true
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = true

package/templates/rust/server/action_map.json

@@ -0,0 +1,3 @@
+{
+  "GET:/rust": "rust_hello"
+}

package/templates/rust/server/actions/hello.jsbundle

@@ -0,0 +1,47 @@
+const defineAction = (fn) => fn;
+var __titan_exports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // app/actions/hello.js
+  var hello_exports = {};
+  __export(hello_exports, {
+    hello: () => hello
+  });
+  var hello = () => {
+    const valid = "hii";
+    t.log(valid);
+  };
+  return __toCommonJS(hello_exports);
+})();
+
+    (function () {
+      const fn =
+        __titan_exports["hello"] ||
+        __titan_exports.default;
+    
+      if (typeof fn !== "function") {
+        throw new Error("[Titan] Action 'hello' not found or not a function");
+      }
+    
+      globalThis["hello"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
+    })();
+    

package/templates/rust/server/routes.json

@@ -0,0 +1,22 @@
+{
+  "__config": {
+    "port": 3000
+  },
+  "routes": {
+    "GET:/rust": {
+      "type": "action",
+      "value": "rust_hello"
+    },
+    "GET:/": {
+      "type": "text",
+      "value": "Ready to land on Titan Planet 🚀"
+    }
+  },
+  "__dynamic_routes": [
+    {
+      "method": "GET",
+      "pattern": "/hello/:id",
+      "action": "hello"
+    }
+  ]
+}

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

@@ -0,0 +1,131 @@
+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,
+    pub value: Value,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct DynamicRoute {
+    pub method: String,
+    pub pattern: String,
+    pub action: String,
+}
+
+// -------------------------
+// ACTION DIRECTORY RESOLUTION
+// -------------------------
+
+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/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("actions");
+                    if candidate.exists() {
+                        return candidate;
+                    }
+                }
+            }
+        }
+    }
+
+    // Fall back to local ./actions
+    PathBuf::from("./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("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
+}
+
+// Dynamic Matcher (Core Logic)
+
+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
+}

package/templates/rust/server/src/actions_rust/mod.rs

@@ -0,0 +1,19 @@
+// Auto-generated by Titan. Do not edit.
+use axum::response::IntoResponse;
+use axum::http::Request;
+use axum::body::Body;
+use std::future::Future;
+use std::pin::Pin;
+
+pub mod rust_hello;
+
+pub type ActionFn = fn(Request<Body>) -> Pin<Box<dyn Future<Output = axum::response::Response> + Send>>;
+
+pub fn get_action(name: &str) -> Option<ActionFn> {
+    match name {
+        "rust_hello" => Some(|req| Box::pin(async move { 
+            rust_hello::run(req).await.into_response() 
+        })),
+        _ => None
+    }
+}

package/templates/rust/server/src/actions_rust/rust_hello.rs

@@ -0,0 +1,14 @@
+use crate::extensions::t;
+use axum::{response::{IntoResponse, Json}, http::Request, body::Body};
+use serde_json::json;
+
+pub async fn run(_req: Request<Body>) -> impl IntoResponse {
+    let _token = t.jwt.sign(json!({"id": 1}), "secret", Some(json!({"expiresIn": "1h"}))).unwrap_or_default();
+    let decoded = t.jwt.verify(&_token, "secret").unwrap_or_default();
+    Json(json!({
+        "message": "Hello from Rust Action! 🦀",
+        "status": "blazing fast test",
+        "token": _token,
+        "decoded": decoded
+    }))
+}

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

@@ -0,0 +1,10 @@
+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()
+    )
+}