npm - @ezetgalaxy/titan - Versions diffs - 26.9.2 → 26.9.3 - Mend

@ezetgalaxy/titan 26.9.2 → 26.9.3

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

package/templates/extension/node_modules/titanpl-sdk/templates/server/src/main.rs ADDED Viewed

@@ -0,0 +1,345 @@
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+use anyhow::Result;
+use axum::{
+    body::{to_bytes, Body},
+    extract::State,
+    http::{Request, StatusCode},
+    response::{IntoResponse, Json},
+    routing::any,
+    Router,
+};
+use serde_json::Value;
+use tokio::net::TcpListener;
+use std::time::Instant;
+mod utils;
+mod extensions;
+mod action_management;
+use utils::{blue, white, yellow, green, gray, red};
+use extensions::{init_v8, inject_extensions};
+use action_management::{
+    resolve_actions_dir, find_actions_dir, match_dynamic_route,
+    DynamicRoute, RouteVal
+};
+#[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
+    // ---------------------------
+    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
+    // ---------------------------
+    // QUERY PARSING
+    // ---------------------------
+    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
+    // ---------------------------
+    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))
+    };
+    // ---------------------------
+    // 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;
+        }
+    }
+    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 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
+        // 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();
+    // Project root — heuristics
+    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    // Ensure we find the 'app' directory as sibling if running from 'server'
+    let project_root = if cwd.join("../app").exists() {
+        cwd.join("../app")
+    } else {
+        cwd
+    };
+    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!("\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);
+    axum::serve(listener, app).await?;
+    Ok(())
+}

package/templates/extension/node_modules/titanpl-sdk/templates/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/extension/node_modules/titanpl-sdk/templates/titan/bundle.js ADDED Viewed

@@ -0,0 +1,65 @@
+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");
+export async function bundle() {
+  console.log("[Titan] Bundling actions...");
+  fs.mkdirSync(outDir, { recursive: true });
+  // Clean old bundles
+  for (const file of fs.readdirSync(outDir)) {
+    fs.unlinkSync(path.join(outDir, file));
+  }
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".js") || f.endsWith(".ts"));
+  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",
+      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}"] = fn;
+    })();
+    `
+      }
+    });
+  }
+  console.log("[Titan] Bundling finished.");
+}

package/templates/extension/node_modules/titanpl-sdk/templates/titan/dev.js ADDED Viewed

@@ -0,0 +1,113 @@
+import chokidar from "chokidar";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import { bundle } from "./bundle.js";
+// Required for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let serverProcess = null;
+async function killServer() {
+    if (!serverProcess) return;
+    const pid = serverProcess.pid;
+    const killPromise = new Promise((resolve) => {
+        if (serverProcess.exitCode !== null) return resolve();
+        serverProcess.once("close", resolve);
+    });
+    if (process.platform === "win32") {
+        try {
+            execSync(`taskkill /pid ${pid} /f /t`, { stdio: 'ignore' });
+        } catch (e) {
+            // Ignore errors if process is already dead
+        }
+    } else {
+        serverProcess.kill();
+    }
+    try {
+        await killPromise;
+    } catch (e) { }
+    serverProcess = null;
+}
+async function startRustServer() {
+    await killServer();
+    // Give the OS a moment to release file locks on the binary
+    await new Promise(r => setTimeout(r, 500));
+    const serverPath = path.join(process.cwd(), "server");
+    serverProcess = spawn("cargo", ["run"], {
+        cwd: serverPath,
+        stdio: "inherit",
+        shell: true
+    });
+    serverProcess.on("close", (code) => {
+        if (code !== null && code !== 0 && code !== 1) {
+            // 1 is often just 'terminated' on windows if forced, but also error.
+            // We just log it.
+        }
+        console.log(`[Titan] Rust server exited: ${code}`);
+    });
+}
+async function rebuild() {
+    console.log("[Titan] Regenerating routes.json & action_map.json...");
+    execSync("node app/app.js", { stdio: "inherit" });
+    console.log("[Titan] Bundling JS actions...");
+    await bundle();
+}
+async function startDev() {
+    console.log("[Titan] Dev mode starting...");
+    if (fs.existsSync(path.join(process.cwd(), ".env"))) {
+        console.log("\x1b[33m[Titan] Env Configured\x1b[0m");
+    }
+    // FIRST BUILD
+    try {
+        await rebuild();
+        await startRustServer();
+    } catch (e) {
+        console.log("\x1b[31m[Titan] Initial build failed. Waiting for changes...\x1b[0m");
+    }
+    const watcher = chokidar.watch(["app", ".env"], {
+        ignoreInitial: true
+    });
+    let timer = null;
+    watcher.on("all", async (event, file) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+            if (file.includes(".env")) {
+                console.log("\x1b[33m[Titan] Env Refreshed\x1b[0m");
+            } else {
+                console.log(`[Titan] Change detected: ${file}`);
+            }
+            try {
+                await rebuild();
+                console.log("[Titan] Restarting Rust server...");
+                await startRustServer();
+            } catch (e) {
+                console.log("\x1b[31m[Titan] Build failed -- waiting for changes...\x1b[0m");
+            }
+        }, 200);
+    });
+}
+startDev();

package/templates/extension/node_modules/titanpl-sdk/templates/titan/titan.js ADDED Viewed

@@ -0,0 +1,98 @@
+import fs from "fs";
+import path from "path";
+import { bundle } from "./bundle.js";
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+const routes = {};
+const dynamicRoutes = {};
+const actionMap = {};
+function addRoute(method, route) {
+  const key = `${method.toUpperCase()}:${route}`;
+  return {
+    reply(value) {
+      routes[key] = {
+        type: typeof value === "object" ? "json" : "text",
+        value
+      };
+    },
+    action(name) {
+      if (route.includes(":")) {
+        if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
+        dynamicRoutes[method].push({
+          method: method.toUpperCase(),
+          pattern: route,
+          action: name
+        });
+      } else {
+        routes[key] = {
+          type: "action",
+          value: name
+        };
+        actionMap[key] = name;
+      }
+    }
+  };
+}
+const t = {
+  get(route) {
+    return addRoute("GET", route);
+  },
+  post(route) {
+    return addRoute("POST", route);
+  },
+  log(module, msg) {
+    console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
+  },
+  async start(port = 3000, msg = "") {
+    try {
+      console.log(cyan("[Titan] Preparing runtime..."));
+      await bundle();
+      const base = path.join(process.cwd(), "server");
+      if (!fs.existsSync(base)) {
+        fs.mkdirSync(base, { recursive: true });
+      }
+      const routesPath = path.join(base, "routes.json");
+      const actionMapPath = path.join(base, "action_map.json");
+      fs.writeFileSync(
+        routesPath,
+        JSON.stringify(
+          {
+            __config: { port },
+            routes,
+            __dynamic_routes: Object.values(dynamicRoutes).flat()
+          },
+          null,
+          2
+        )
+      );
+      fs.writeFileSync(
+        actionMapPath,
+        JSON.stringify(actionMap, null, 2)
+      );
+      console.log(green("✔ Titan metadata written successfully"));
+      if (msg) console.log(cyan(msg));
+    } catch (e) {
+      console.error(`\x1b[31m[Titan] Build Error: ${e.message}\x1b[0m`);
+      process.exit(1);
+    }
+  }
+};
+globalThis.t = t;
+export default t;