npm - @ezetgalaxy/titan - Versions diffs - 26.7.5 → 26.8.2 - Mend

@ezetgalaxy/titan 26.7.5 → 26.8.2

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 (53) hide show

package/README.md +86 -200
package/index.js +87 -23
package/package.json +4 -3
package/templates/js/_gitignore +37 -0
package/templates/{package.json → js/package.json} +3 -0
package/templates/{server → js/server}/actions/hello.jsbundle +4 -1
package/templates/{server → js/server}/src/extensions.rs +149 -17
package/templates/{server → js/server}/src/main.rs +1 -6
package/templates/{titan → js/titan}/bundle.js +22 -9
package/templates/js/titan/dev.js +258 -0
package/templates/js/titan/titan.js +122 -0
package/templates/rust/Dockerfile +66 -0
package/templates/rust/_dockerignore +3 -0
package/templates/rust/_gitignore +37 -0
package/templates/rust/app/actions/hello.js +5 -0
package/templates/rust/app/actions/rust_hello.rs +14 -0
package/templates/rust/app/app.js +11 -0
package/templates/rust/app/titan.d.ts +101 -0
package/templates/rust/jsconfig.json +19 -0
package/templates/rust/package.json +13 -0
package/templates/rust/server/Cargo.lock +2869 -0
package/templates/rust/server/Cargo.toml +39 -0
package/templates/rust/server/action_map.json +3 -0
package/templates/rust/server/actions/hello.jsbundle +47 -0
package/templates/rust/server/routes.json +22 -0
package/templates/rust/server/src/action_management.rs +131 -0
package/templates/rust/server/src/actions_rust/mod.rs +19 -0
package/templates/rust/server/src/actions_rust/rust_hello.rs +14 -0
package/templates/rust/server/src/errors.rs +10 -0
package/templates/rust/server/src/extensions.rs +989 -0
package/templates/rust/server/src/main.rs +437 -0
package/templates/rust/server/src/utils.rs +33 -0
package/templates/rust/titan/bundle.js +157 -0
package/templates/rust/titan/dev.js +266 -0
package/templates/{titan → rust/titan}/titan.js +122 -98
package/titanpl-sdk/templates/Dockerfile +4 -17
package/titanpl-sdk/templates/server/src/extensions.rs +218 -423
package/titanpl-sdk/templates/server/src/main.rs +68 -134
package/templates/_gitignore +0 -25
package/templates/titan/dev.js +0 -144
/package/templates/{Dockerfile → js/Dockerfile} +0 -0
/package/templates/{.dockerignore → js/_dockerignore} +0 -0
/package/templates/{app → js/app}/actions/hello.js +0 -0
/package/templates/{app → js/app}/app.js +0 -0
/package/templates/{app → js/app}/titan.d.ts +0 -0
/package/templates/{jsconfig.json → js/jsconfig.json} +0 -0
/package/templates/{server → js/server}/Cargo.lock +0 -0
/package/templates/{server → js/server}/Cargo.toml +0 -0
/package/templates/{server → js/server}/action_map.json +0 -0
/package/templates/{server → js/server}/routes.json +0 -0
/package/templates/{server → js/server}/src/action_management.rs +0 -0
/package/templates/{server → js/server}/src/errors.rs +0 -0
/package/templates/{server → js/server}/src/utils.rs +0 -0

package/templates/rust/server/src/main.rs ADDED Viewed

@@ -0,0 +1,437 @@
+use anyhow::Result;
+use axum::{
+    Router,
+    body::{Body, to_bytes},
+    extract::State,
+    http::{Request, StatusCode},
+    response::{IntoResponse, Json},
+    routing::any,
+};
+use serde_json::Value;
+use std::time::Instant;
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+use tokio::net::TcpListener;
+mod utils;
+mod action_management;
+mod extensions;
+mod actions_rust;
+use action_management::{
+    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 {
+    routes: Arc<HashMap<String, RouteVal>>,
+    dynamic_routes: Arc<Vec<DynamicRoute>>,
+    project_root: PathBuf,
+}
+// Root/dynamic handlers -----------------------------------------------------
+async fn root_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
+    dynamic_handler_inner(state, req).await
+}
+async fn dynamic_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
+    dynamic_handler_inner(state, req).await
+}
+async fn dynamic_handler_inner(
+    State(state): State<AppState>,
+    req: Request<Body>,
+) -> impl IntoResponse {
+    // ---------------------------
+    // BASIC REQUEST INFO (No body consumption yet)
+    // ---------------------------
+    let method = req.method().as_str().to_uppercase();
+    let path = req.uri().path().to_string();
+    let key = format!("{}:{}", method, path);
+    // ---------------------------
+    // TIMER + LOG META
+    // ---------------------------
+    let start = Instant::now();
+    let mut route_label = String::from("not_found");
+    let mut route_kind = "none"; // exact | dynamic | reply
+    // ---------------------------
+    // ROUTE RESOLUTION
+    // ---------------------------
+    let mut params: HashMap<String, String> = HashMap::new();
+    let mut action_name: Option<String> = None;
+    // Exact route
+    if let Some(route) = state.routes.get(&key) {
+        route_kind = "exact";
+        if route.r#type == "action" {
+            let name = route.value.as_str().unwrap_or("unknown").to_string();
+            route_label = name.clone();
+            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))
+            );
+            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))
+            );
+            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())
+        {
+            route_kind = "dynamic";
+            route_label = action.clone();
+            action_name = Some(action);
+            params = p;
+        }
+    }
+    // ---------------------------
+    // RUST ACTION CHECK
+    // ---------------------------
+    if let Some(name) = &action_name {
+        if let Some(rust_action) = actions_rust::get_action(name) {
+             let elapsed = start.elapsed();
+             match route_kind {
+                "dynamic" => println!(
+                    "{} {} {} {} {} {}",
+                    blue("[Titan]"),
+                    green(&format!("{} {}", method, path)),
+                    white("→"),
+                    green(&route_label),
+                    white("(rust)"),
+                    gray(&format!("in {:.2?}", elapsed))
+                ),
+                "exact" => println!(
+                    "{} {} {} {} {} {}",
+                    blue("[Titan]"),
+                    white(&format!("{} {}", method, path)),
+                    white("→"),
+                    yellow(&route_label),
+                    white("(rust)"),
+                    gray(&format!("in {:.2?}", elapsed))
+                ),
+                _ => {}
+            }
+            return rust_action(req).await.into_response();
+        }
+    }
+    // ---------------------------
+    // QUERY PARSING (For JS)
+    // ---------------------------
+    let query: HashMap<String, String> = req
+        .uri()
+        .query()
+        .map(|q| {
+            q.split('&')
+                .filter_map(|pair| {
+                    let mut it = pair.splitn(2, '=');
+                    Some((it.next()?.to_string(), it.next().unwrap_or("").to_string()))
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    // ---------------------------
+    // HEADERS & BODY (CONSUME REQ)
+    // ---------------------------
+    let (parts, body) = req.into_parts();
+    let headers = parts
+        .headers
+        .iter()
+        .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
+        .collect::<HashMap<String, String>>();
+    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(),
+    };
+    let body_str = String::from_utf8_lossy(&body_bytes).to_string();
+    let body_json: Value = if body_str.is_empty() {
+        Value::Null
+    } else {
+        serde_json::from_str(&body_str).unwrap_or(Value::String(body_str))
+    };
+    let action_name = match action_name {
+        Some(a) => a,
+        None => {
+            let elapsed = start.elapsed();
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ 404"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
+            return (StatusCode::NOT_FOUND, "Not Found").into_response();
+        }
+    };
+    // ---------------------------
+    // LOAD JS ACTION
+    // ---------------------------
+    let resolved = resolve_actions_dir();
+    let actions_dir = resolved
+        .exists()
+        .then(|| resolved)
+        .or_else(|| find_actions_dir(&state.project_root))
+        .unwrap();
+    let mut action_path = actions_dir.join(format!("{}.jsbundle", action_name));
+    if !action_path.exists() {
+        let js_path = actions_dir.join(format!("{}.js", action_name));
+        if js_path.exists() {
+            action_path = js_path;
+        }
+    }
+    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 injected = format!(
+        r#"
+        globalThis.process = {{ env: {} }};
+        const __titan_req = {{
+            body: {},
+            method: "{}",
+            path: "{}",
+            headers: {},
+            params: {},
+            query: {}
+        }};
+        (function() {{
+            {}
+        }})(); // Run the bundle
+        // Call the action
+        if (typeof globalThis["{}"] === 'function') {{
+            globalThis["{}"](__titan_req);
+        }} else {{
+            throw new Error("Action function '{}' not found in bundle");
+        }}
+        "#,
+        Value::Object(env_json).to_string(),
+        body_json.to_string(),
+        method,
+        path,
+        serde_json::to_string(&headers).unwrap(),
+        serde_json::to_string(&params).unwrap(),
+        serde_json::to_string(&query).unwrap(),
+        js_code,
+        action_name,
+        action_name,
+        action_name
+    );
+    // Run V8 in a blocking task safely?
+    // Axum handlers are async. V8 operations should be blocking.
+    // 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
+        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" });
+            }
+        };
+        let result = script.run(try_catch);
+        match result {
+            Some(val) => {
+                // Convert v8 Value to Serde JSON
+                // Minimal impl: stringify
+                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" })
+            }
+        }
+    })
+    .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!("{}", 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))
+        ),
+        _ => {}
+    }
+    Json(result_json).into_response()
+}
+// Entrypoint ---------------------------------------------------------------
+#[tokio::main]
+async fn main() -> Result<()> {
+    dotenvy::dotenv().ok();
+    init_v8(); // Init platform once
+    // Load routes.json
+    let raw = fs::read_to_string("./routes.json").unwrap_or_else(|_| "{}".to_string());
+    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();
+    let dynamic_routes: Vec<DynamicRoute> =
+        serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
+    // 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);
+    let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
+    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("."))
+}

package/templates/rust/server/src/utils.rs ADDED Viewed

@@ -0,0 +1,33 @@
+pub fn blue(s: &str) -> String {
+    format!("\x1b[38;5;39m{}\x1b[0m", s)
+}
+pub fn white(s: &str) -> String {
+    format!("\x1b[39m{}\x1b[0m", s)
+}
+pub fn yellow(s: &str) -> String {
+    format!("\x1b[33m{}\x1b[0m", s)
+}
+pub fn green(s: &str) -> String {
+    format!("\x1b[32m{}\x1b[0m", s)
+}
+pub fn gray(s: &str) -> String {
+    format!("\x1b[90m{}\x1b[0m", s)
+}
+pub fn red(s: &str) -> String {
+    format!("\x1b[31m{}\x1b[0m", s)
+}
+pub fn parse_expires_in(value: &str) -> Option<u64> {
+    let (num, unit) = value.split_at(value.len() - 1);
+    let n: u64 = num.parse().ok()?;
+    match unit {
+        "s" => Some(n),
+        "m" => Some(n * 60),
+        "h" => Some(n * 60 * 60),
+        "d" => Some(n * 60 * 60 * 24),
+        _ => None,
+    }
+}

package/templates/rust/titan/bundle.js ADDED Viewed

@@ -0,0 +1,157 @@
+import fs from "fs";
+import path from "path";
+import esbuild from "esbuild";
+const root = process.cwd();
+const actionsDir = path.join(root, "app", "actions");
+const outDir = path.join(root, "server", "actions");
+const rustOutDir = path.join(root, "server", "src", "actions_rust");
+export async function bundle() {
+  const start = Date.now();
+  await bundleJs();
+  await bundleRust();
+  // console.log(`[Titan] Bundle finished in ${((Date.now() - start) / 1000).toFixed(2)}s`);
+}
+async function bundleJs() {
+  // console.log("[Titan] Bundling JS actions...");
+  fs.mkdirSync(outDir, { recursive: true });
+  // Clean old bundles
+  const oldFiles = fs.readdirSync(outDir);
+  for (const file of oldFiles) {
+    fs.unlinkSync(path.join(outDir, file));
+  }
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".js") || f.endsWith(".ts"));
+  if (files.length === 0) return;
+  // console.log(`[Titan] Bundling ${files.length} JS actions...`);
+  for (const file of files) {
+    const actionName = path.basename(file, path.extname(file));
+    const entry = path.join(actionsDir, file);
+    // Rust runtime expects `.jsbundle` extension — consistent with previous design
+    const outfile = path.join(outDir, actionName + ".jsbundle");
+    // console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+    await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      format: "iife",
+      globalName: "__titan_exports",
+      platform: "neutral",
+      target: "es2020",
+      logLevel: "silent",
+      banner: {
+        js: "const defineAction = (fn) => fn;"
+      },
+      footer: {
+        js: `
+    (function () {
+      const fn =
+        __titan_exports["${actionName}"] ||
+        __titan_exports.default;
+      if (typeof fn !== "function") {
+        throw new Error("[Titan] Action '${actionName}' not found or not a function");
+      }
+      globalThis["${actionName}"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
+    })();
+    `
+      }
+    });
+  }
+  // console.log("[Titan] JS Bundling finished.");
+}
+export async function bundleRust() {
+  // console.log("[Titan] Bundling Rust actions...");
+  if (!fs.existsSync(rustOutDir)) {
+    fs.mkdirSync(rustOutDir, { recursive: true });
+  }
+  // Clean old rust actions
+  for (const file of fs.readdirSync(rustOutDir)) {
+    fs.unlinkSync(path.join(rustOutDir, file));
+  }
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".rs"));
+  if (files.length > 0) {
+    // console.log(`[Titan] Bundling ${files.length} Rust actions...`);
+  }
+  const modules = [];
+  for (const file of files) {
+    const actionName = path.basename(file, ".rs");
+    const entry = path.join(actionsDir, file);
+    let outfile = path.join(rustOutDir, file);
+    let content = fs.readFileSync(entry, 'utf-8');
+    // Prepend implicit imports if not present
+    let finalContent = content;
+    if (!content.includes("use crate::extensions::t;")) {
+      finalContent = "use crate::extensions::t;\n" + content;
+    }
+    // Basic validation - check if it has a run function
+    if (!content.includes("async fn run")) {
+      console.warn(`[Titan] Warning: ${file} does not appear to have an 'async fn run'. It might fail to compile.`);
+    }
+    fs.writeFileSync(outfile, finalContent);
+    modules.push(actionName);
+    // console.log(`[Titan] Copied Rust action ${actionName}`);
+  }
+  // Generate mod.rs
+  let modContent = `// 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;
+`;
+  // Add mod declarations
+  for (const mod of modules) {
+    modContent += `pub mod ${mod};\n`;
+  }
+  modContent += `
+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 {
+`;
+  for (const mod of modules) {
+    modContent += `        "${mod}" => Some(|req| Box::pin(async move {
+            ${mod}::run(req).await.into_response()
+        })),\n`;
+  }
+  modContent += `        _ => None
+    }
+}
+`;
+  fs.writeFileSync(path.join(rustOutDir, "mod.rs"), modContent);
+  // console.log("[Titan] Rust Bundling finished.");
+}