@ezetgalaxy/titan 26.7.5 → 26.8.2

package/templates/{server → js/server}/src/extensions.rs

@@ -3,6 +3,7 @@ use bcrypt::{DEFAULT_COST, hash, verify};
 use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode};
 use reqwest::{
     blocking::Client,
+    Method,
     header::{HeaderMap, HeaderName, HeaderValue},
 };
 use serde_json::Value;
@@ -18,6 +19,148 @@ use std::fs;
 use std::sync::Mutex;
 use walkdir::WalkDir;
 
+
+// ----------------------------------------------------------------------------
+// RUST ACTION API
+// ----------------------------------------------------------------------------
+
+pub struct T {
+    pub jwt: Jwt,
+    pub password: Password,
+}
+
+#[allow(non_upper_case_globals)]
+pub static t: T = T {
+    jwt: Jwt,
+    password: Password,
+};
+
+pub struct Jwt;
+impl Jwt {
+    pub fn sign(&self, payload: Value, secret: &str, options: Option<Value>) -> anyhow::Result<String> {
+        let mut final_payload = match payload {
+            Value::Object(map) => map,
+            _ => serde_json::Map::new(), // Should probably error or handle string payload like JS
+        };
+
+        if let Some(opts) = options {
+             if let Some(exp_val) = opts.get("expiresIn") {
+                // Handle both number (seconds) and string ("1h")
+                let seconds = if let Some(n) = exp_val.as_u64() {
+                    Some(n)
+                } else if let Some(s) = exp_val.as_str() {
+                    parse_expires_in(s)
+                } else {
+                    None
+                };
+
+                if let Some(sec) = seconds {
+                     let now = SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .unwrap()
+                        .as_secs();
+                    final_payload.insert("exp".to_string(), Value::Number(serde_json::Number::from(now + sec)));
+                }
+             }
+        }
+
+        let token = encode(
+            &Header::default(),
+            &Value::Object(final_payload),
+            &EncodingKey::from_secret(secret.as_bytes()),
+        )?;
+        Ok(token)
+    }
+
+    pub fn verify(&self, token: &str, secret: &str) -> anyhow::Result<Value> {
+        let mut validation = Validation::default();
+        validation.validate_exp = true; 
+
+        let data = decode::<Value>(
+            token,
+            &DecodingKey::from_secret(secret.as_bytes()),
+            &validation,
+        )?;
+        Ok(data.claims)
+    }
+}
+
+pub struct Password;
+impl Password {
+    pub fn hash(&self, password: &str) -> anyhow::Result<String> {
+        let h = hash(password, DEFAULT_COST)?;
+        Ok(h)
+    }
+
+    pub fn verify(&self, password: &str, hash_str: &str) -> bool {
+        verify(password, hash_str).unwrap_or(false)
+    }
+}
+
+impl T {
+    pub fn log(&self, msg: impl std::fmt::Display) {
+        println!(
+            "{} {}",
+            blue("[Titan]"),
+            gray(&format!("\x1b[90mlog(rust)\x1b[0m\x1b[97m: {}\x1b[0m", msg))
+        );
+    }
+
+    pub fn read(&self, path: &str) -> anyhow::Result<String> {
+        let root = std::env::current_dir()?;
+        let target = root.join(path);
+        let target = target.canonicalize()?;
+        Ok(fs::read_to_string(target)?)
+    }
+
+    pub async fn fetch(&self, url: &str, options: Option<FetchOptions>) -> anyhow::Result<FetchResponse> {
+        let client = reqwest::Client::new();
+        let opts = options.unwrap_or_default();
+        
+        let mut req = client.request(opts.method.parse().unwrap_or(Method::GET), url);
+
+        if let Some(headers) = opts.headers {
+            let mut map = HeaderMap::new();
+            for (k, v) in headers {
+                if let (Ok(name), Ok(val)) = (
+                    HeaderName::from_bytes(k.as_bytes()),
+                    HeaderValue::from_str(&v),
+                ) {
+                    map.insert(name, val);
+                }
+            }
+            req = req.headers(map);
+        }
+
+        if let Some(body) = opts.body {
+            req = req.body(body);
+        }
+
+        let res = req.send().await?;
+        let status = res.status().as_u16();
+        let text = res.text().await?;
+
+        Ok(FetchResponse {
+            status,
+            body: text,
+            ok: status >= 200 && status < 300
+        })
+    }
+}
+
+#[derive(Default)]
+pub struct FetchOptions {
+    pub method: String,
+    pub headers: Option<std::collections::HashMap<String, String>>,
+    pub body: Option<String>,
+}
+
+pub struct FetchResponse {
+    pub status: u16,
+    pub body: String,
+    pub ok: bool,
+}
+
 // ----------------------------------------------------------------------------
 // GLOBAL REGISTRY
 // ----------------------------------------------------------------------------
@@ -109,14 +252,16 @@ pub fn load_project_extensions(root: PathBuf) {
     search_dirs.sort();
     search_dirs.dedup();
 
-    println!("{} Scanning extension directories:", blue("[Titan]"));
+    // println!("{} Scanning extension directories:", blue("[Titan]"));
     for d in &search_dirs {
+        /*
         let label = if d.to_string_lossy().contains(".ext") {
              crate::utils::green("(Production)")
         } else {
              crate::utils::yellow("(Development)")
         };
         println!("   • {} {}", d.display(), label);
+        */
     }
 
     // =====================================================
@@ -245,20 +390,7 @@ pub fn load_project_extensions(root: PathBuf) {
     // 5. Store registry globally
     // =====================================================
     if modules.is_empty() {
-         println!("{} {}", blue("[Titan]"), crate::utils::yellow("No extensions loaded."));
-         // Debug: list files in search dirs to assist debugging
-         for dir in &search_dirs {
-             if dir.exists() {
-                 println!("{} Listing contents of {}:", blue("[Titan]"), dir.display());
-                 for entry in WalkDir::new(dir).max_depth(5) {
-                      if let Ok(e) = entry {
-                          println!("   - {}", e.path().display());
-                      }
-                 }
-             } else {
-                 println!("{} Directory not found: {}", blue("[Titan]"), dir.display());
-             }
-         }
+         // println!("{} {}", blue("[Titan]"), crate::utils::yellow("No extensions loaded."));
     }
 
     *REGISTRY.lock().unwrap() = Some(Registry {
@@ -333,7 +465,7 @@ fn native_read(
 
     // 3. Canonicalize (resolves ../)
     let target = match joined.canonicalize() {
-        Ok(t) => t,
+        Ok(target) => target,
         Err(_) => {
             throw(scope, &format!("t.read: file not found: {}", path_str));
             return;
@@ -554,7 +686,7 @@ fn native_jwt_sign(
     );
 
     match token {
-        Ok(t) => retval.set(v8_str(scope, &t).into()),
+        Ok(tok) => retval.set(v8_str(scope, &tok).into()),
         Err(e) => throw(scope, &e.to_string()),
     }
 }

package/templates/{server → js/server}/src/main.rs

@@ -368,12 +368,7 @@ async fn main() -> Result<()> {
 
     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

package/templates/{titan → js/titan}/bundle.js

@@ -7,16 +7,28 @@ const actionsDir = path.join(root, "app", "actions");
 const outDir = path.join(root, "server", "actions");
 
 export async function bundle() {
-  console.log("[Titan] Bundling actions...");
+  const start = Date.now();
+  await bundleJs();
+  // 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
-  for (const file of fs.readdirSync(outDir)) {
-    fs.unlinkSync(path.join(outDir, file));
+  if (fs.existsSync(outDir)) {
+    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));
@@ -26,7 +38,7 @@ export async function bundle() {
     // Rust runtime expects `.jsbundle` extension — consistent with previous design
     const outfile = path.join(outDir, actionName + ".jsbundle");
 
-    console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+    // console.log(`[Titan] Bundling ${entry} → ${outfile}`);
 
     await esbuild.build({
       entryPoints: [entry],
@@ -36,6 +48,7 @@ export async function bundle() {
       globalName: "__titan_exports",
       platform: "neutral",
       target: "es2020",
+      logLevel: "silent",
       banner: {
         js: "const defineAction = (fn) => fn;"
       },
@@ -51,15 +64,15 @@ export async function bundle() {
         throw new Error("[Titan] Action '${actionName}' not found or not a function");
       }
     
-      globalThis["${actionName}"] = fn;
+      globalThis["${actionName}"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
     })();
     `
       }
     });
-
-
-
   }
 
-  console.log("[Titan] Bundling finished.");
+  // console.log("[Titan] JS Bundling finished.");
 }

package/templates/js/titan/dev.js

@@ -0,0 +1,258 @@
+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);
+
+
+// Colors
+import { createRequire } from "module";
+
+// Colors
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+const red = (t) => `\x1b[31m${t}\x1b[0m`;
+const gray = (t) => `\x1b[90m${t}\x1b[0m`;
+const bold = (t) => `\x1b[1m${t}\x1b[0m`;
+
+function getTitanVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    } catch (e) {
+        try {
+            // Check levels up to find the framework root
+            let cur = __dirname;
+            for (let i = 0; i < 5; i++) {
+                const pkgPath = path.join(cur, "package.json");
+                if (fs.existsSync(pkgPath)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                    if (pkg.name === "@ezetgalaxy/titan") return pkg.version;
+                }
+                cur = path.join(cur, "..");
+            }
+        } catch (e2) { }
+    }
+    return "0.1.0";
+}
+
+let serverProcess = null;
+let isKilling = false;
+
+// ... (killServer same as before) 
+async function killServer() {
+    if (!serverProcess) return;
+
+    isKilling = true;
+    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;
+    isKilling = false;
+}
+
+const delay = (ms) => new Promise(res => setTimeout(res, ms));
+
+let spinnerTimer = null;
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+let frameIdx = 0;
+
+function startSpinner(text) {
+    if (spinnerTimer) clearInterval(spinnerTimer);
+    process.stdout.write("\x1B[?25l"); // Hide cursor
+    spinnerTimer = setInterval(() => {
+        process.stdout.write(`\r  ${cyan(frames[frameIdx])} ${gray(text)}`);
+        frameIdx = (frameIdx + 1) % frames.length;
+    }, 80);
+}
+
+function stopSpinner(success = true, text = "") {
+    if (spinnerTimer) {
+        clearInterval(spinnerTimer);
+        spinnerTimer = null;
+    }
+    process.stdout.write("\r\x1B[K"); // Clear line
+    process.stdout.write("\x1B[?25h"); // Show cursor
+    if (text) {
+        if (success) {
+            console.log(`  ${green("✔")} ${green(text)}`);
+        } else {
+            console.log(`  ${red("✖")} ${red(text)}`);
+        }
+    }
+}
+
+async function startRustServer(retryCount = 0) {
+    const waitTime = retryCount > 0 ? 500 : 200;
+
+    await killServer();
+    await delay(waitTime);
+
+    const serverPath = path.join(process.cwd(), "server");
+    const startTime = Date.now();
+
+    startSpinner("Stabilizing your app on its orbit...");
+
+    let isReady = false;
+    let stdoutBuffer = "";
+    let buildLogs = "";
+
+    // If it takes more than 15s, update the message
+    const slowTimer = setTimeout(() => {
+        if (!isReady && !isKilling) {
+            startSpinner("Still stabilizing... (the first orbit takes longer)");
+        }
+    }, 15000);
+
+    serverProcess = spawn("cargo", ["run", "--quiet"], {
+        cwd: serverPath,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, CARGO_INCREMENTAL: "1" }
+    });
+
+    serverProcess.on("error", (err) => {
+        stopSpinner(false, "Failed to start orbit");
+        console.error(red(`[Titan] Error: ${err.message}`));
+    });
+
+    serverProcess.stderr.on("data", (data) => {
+        const str = data.toString();
+        if (isReady) {
+            process.stderr.write(data);
+        } else {
+            buildLogs += str;
+        }
+    });
+
+    serverProcess.stdout.on("data", (data) => {
+        const out = data.toString();
+
+        if (!isReady) {
+            stdoutBuffer += out;
+            if (stdoutBuffer.includes("Titan server running") || stdoutBuffer.includes("████████╗")) {
+                isReady = true;
+                clearTimeout(slowTimer);
+                stopSpinner(true, "Your app is now orbiting Titan Planet");
+                process.stdout.write(stdoutBuffer);
+                stdoutBuffer = "";
+            }
+        } else {
+            process.stdout.write(data);
+        }
+    });
+
+    serverProcess.on("close", async (code) => {
+        clearTimeout(slowTimer);
+        if (isKilling) return;
+        const runTime = Date.now() - startTime;
+
+        if (code !== 0 && code !== null) {
+            stopSpinner(false, "Orbit stabilization failed");
+            if (!isReady) {
+                console.log(gray("\n--- Build Logs ---"));
+                console.log(buildLogs);
+                console.log(gray("------------------\n"));
+            }
+
+            if (runTime < 15000 && retryCount < 5) {
+                await delay(2000);
+                await startRustServer(retryCount + 1);
+            }
+        }
+    });
+}
+
+async function rebuild() {
+    try {
+        execSync("node app/app.js", { stdio: "ignore" });
+        // bundle is called inside app.js (t.start)
+    } catch (e) {
+        stopSpinner(false, "Failed to prepare runtime");
+        console.log(red(`[Titan] Error: ${e.message}`));
+    }
+}
+
+async function startDev() {
+    const root = process.cwd();
+    const actionsDir = path.join(root, "app", "actions");
+    let hasRust = false;
+    if (fs.existsSync(actionsDir)) {
+        hasRust = fs.readdirSync(actionsDir).some(f => f.endsWith(".rs"));
+    }
+
+    const mode = hasRust ? "Rust + JS Actions" : "JS Actions";
+    const version = getTitanVersion();
+
+    console.clear();
+    console.log("");
+    console.log(`  ${bold(cyan("Titan Planet"))}   ${gray("v" + version)}   ${yellow("[ Dev Mode ]")}`);
+    console.log("");
+    console.log(`  ${gray("Type:       ")} ${mode}`);
+    console.log(`  ${gray("Hot Reload: ")} ${green("Enabled")}`);
+
+    if (fs.existsSync(path.join(root, ".env"))) {
+        console.log(`  ${gray("Env:        ")} ${yellow("Loaded")}`);
+    }
+    console.log("");
+
+    try {
+        await rebuild();
+        await startRustServer();
+    } catch (e) {
+        // console.log(red("[Titan] Initial build failed. Waiting for changes..."));
+    }
+
+    const watcher = chokidar.watch(["app", ".env"], {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+    });
+
+    let timer = null;
+    watcher.on("all", async (event, file) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+            try {
+                await killServer();
+                await rebuild();
+                await startRustServer();
+            } catch (e) {
+                // console.log(red("[Titan] Build failed -- waiting for changes..."));
+            }
+        }, 300);
+    });
+}
+
+async function handleExit() {
+    stopSpinner();
+    console.log(gray("\n[Titan] Stopping server..."));
+    await killServer();
+    process.exit(0);
+}
+
+process.on("SIGINT", handleExit);
+process.on("SIGTERM", handleExit);
+
+startDev();

package/templates/js/titan/titan.js

@@ -0,0 +1,122 @@
+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;
+      }
+    }
+  };
+}
+
+/**
+ * @typedef {Object} RouteHandler
+ * @property {(value: any) => void} reply - Send a direct response
+ * @property {(name: string) => void} action - Bind to a server-side action
+ */
+
+/**
+ * Titan App Builder
+ */
+const t = {
+  /**
+   * Define a GET route
+   * @param {string} route 
+   * @returns {RouteHandler}
+   */
+  get(route) {
+    return addRoute("GET", route);
+  },
+
+  /**
+   * Define a POST route
+   * @param {string} route 
+   * @returns {RouteHandler}
+   */
+  post(route) {
+    return addRoute("POST", route);
+  },
+
+  log(module, msg) {
+    console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
+  },
+
+  /**
+   * Start the Titan Server
+   * @param {number} [port=3000] 
+   * @param {string} [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);
+    }
+  }
+};
+
+
+export default t;