@ezetgalaxy/titan 25.11.6 → 25.11.8

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import fs from "fs";
 import path from "path";
 import { execSync, spawn } from "child_process";
@@ -43,6 +43,7 @@ ${green("tit init <project>")}   Create new Titan project
 ${green("tit dev")}              Dev mode (hot reload)
 ${green("tit build")}            Build production Rust server
 ${green("tit start")}            Start production binary
+${green("tit update")}           Update to latest version
 `);
 }
 
@@ -61,6 +62,14 @@ function initProject(name) {
     console.log(cyan(`Creating Titan project → ${target}`));
 
     copyDir(templateDir, target);
+    copyDir(templateDir, target);
+
+    [".gitignore", ".dockerignore", "Dockerfile"].forEach((file) => {
+        const src = path.join(templateDir, file);
+        const dest = path.join(target, file);
+        if (fs.existsSync(src)) fs.copyFileSync(src, dest);
+    });
+
 
     console.log(green("✔ Titan project created!"));
     console.log(cyan("Installing dependencies..."));
@@ -187,6 +196,42 @@ function startProd() {
     execSync(`"${exe}"`, { stdio: "inherit" });
 }
 
+// ------------------------------------------
+// TITAN UPDATE — Upgrade titan/ runtime
+// ------------------------------------------
+function updateTitan() {
+    const projectTitan = path.join(process.cwd(), "titan");
+    const cliTitan = path.join(__dirname, "templates", "titan");
+
+    if (!fs.existsSync(projectTitan)) {
+        console.log(red("No titan/ folder found in this project."));
+        console.log(yellow("Make sure you are inside a Titan project."));
+        return;
+    }
+
+    console.log(cyan("Titan: Updating runtime files..."));
+
+    // Backup old titan folder
+    const backupDir = path.join(process.cwd(), `titan_backup_${Date.now()}`);
+    fs.renameSync(projectTitan, backupDir);
+
+    console.log(green(`✔ Backup created → ${backupDir}`));
+
+    copyDir(cliTitan, projectTitan);
+    copyDir(templateDir, target);
+
+    [".gitignore", ".dockerignore", "Dockerfile"].forEach((file) => {
+        const src = path.join(templateDir, file);
+        const dest = path.join(target, file);
+        if (fs.existsSync(src)) fs.copyFileSync(src, dest);
+    });
+
+
+    console.log(green("✔ Titan runtime updated successfully!"));
+    console.log(cyan("Your project now has the latest Titan features."));
+}
+
+
 // ROUTER
 switch (cmd) {
     case "init":
@@ -205,6 +250,11 @@ switch (cmd) {
         startProd();
         break;
 
+    case "update":
+        updateTitan();
+        break;
+
     default:
         help();
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "25.11.6",
+  "version": "25.11.8",
   "description": "JavaScript backend framework that compiles your JS into a Rust + Axum server.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/.dockerignore

@@ -0,0 +1,3 @@
+node_modules
+npm-debug.log
+.git

package/templates/Dockerfile

@@ -0,0 +1,40 @@
+# Stage 1 — Build Titan (JS → Rust)
+FROM rust:1.91.1 AS builder
+
+# Install Node for Titan CLI
+RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs
+
+# Install Titan CLI AND its required dependencies
+RUN npm install -g @ezetgalaxy/titan esbuild chokidar
+
+WORKDIR /app
+
+# Copy project
+COPY . .
+
+# Install Titan dependencies LOCALLY
+RUN npm install esbuild chokidar
+
+# Build Titan metadata (routes + bundles)
+RUN tit build
+
+# Build Rust release binary
+RUN cd server && cargo build --release
+
+# Stage 2 — Run Titan server
+FROM debian:stable-slim
+
+WORKDIR /app
+
+# Copy final Rust binary
+COPY --from=builder /app/server/target/release/server ./titan-server
+
+# Copy Titan runtime files
+COPY --from=builder /app/server/routes.json .
+COPY --from=builder /app/server/action_map.json .
+COPY --from=builder /app/server/actions ./actions
+
+EXPOSE 3000
+
+CMD ["./titan-server"]

package/templates/server/Cargo.lock

@@ -393,6 +393,12 @@ version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77c90badedccf4105eca100756a0b1289e191f6fcbdadd3cee1d2f614f97da8f"
 
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
 [[package]]
 name = "dynify"
 version = "0.1.2"
@@ -1807,6 +1813,7 @@ dependencies = [
  "axum",
  "boa_engine",
  "dotenv",
+ "dotenvy",
  "reqwest",
  "serde",
  "serde_json",

package/templates/server/Cargo.toml

@@ -17,3 +17,4 @@ tracing = "0.1.43"
 tracing-subscriber = "0.3.22"
 anyhow = "1"
 boa_engine = "0.21.0"
+dotenvy = "0.15"

package/templates/server/src/main.rs

@@ -9,11 +9,18 @@ use axum::{
     routing::any,
     Router,
 };
-use boa_engine::{Context, JsValue, Source};
+use boa_engine::{
+    Context,
+    Source
+};
+
 use serde::Deserialize;
 use serde_json::Value;
 use tokio::net::TcpListener;
 
+
+
+
 // ----------------------
 // Route structures
 // ----------------------
@@ -63,72 +70,88 @@ async fn dynamic_handler_inner(
             // ACTION ROUTE
             // --------------------------
             "action" => {
-                let action_name = route.value.as_str().unwrap_or("").trim();
-                if action_name.is_empty() {
-                    return (
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        "Invalid action name",
-                    ).into_response();
-                }
+    let action_name = route.value.as_str().unwrap_or("").trim();
+    if action_name.is_empty() {
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Invalid action name",
+        )
+        .into_response();
+    }
 
-                // correct action path (bundle path)
-                let action_path = state
-                    .project_root
-                    .join("server")
-                    .join("actions")
-                    .join(format!("{}.jsbundle", action_name));
-
-                if !action_path.exists() {
-                    return (
-                        StatusCode::NOT_FOUND,
-                        format!("Action bundle not found: {:?}", action_path),
-                    )
-                    .into_response();
-                }
+    // correct action path
+    let action_path = state
+        .project_root
+        .join("server")
+        .join("actions")
+        .join(format!("{}.jsbundle", action_name));
+
+    if !action_path.exists() {
+        return (
+            StatusCode::NOT_FOUND,
+            format!("Action bundle not found: {:?}", action_path),
+        )
+        .into_response();
+    }
 
-                // read JS bundle
-                let js_code = match fs::read_to_string(action_path) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        return (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("Failed reading action bundle: {}", e),
-                        ).into_response()
-                    }
-                };
-
-                // inject request
-                let injected = format!(
-                    "const __titan_req = {};\n{};\n{}(__titan_req);",
-                    body_str,
-                    js_code,
-                    action_name
-                );                
-
-                // exec in Boa
-                let mut ctx = Context::default();
-                let result = match ctx.eval(Source::from_bytes(&injected)) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        return (
-                            StatusCode::INTERNAL_SERVER_ERROR,
-                            format!("JS execution error: {}", e.to_string()),
-                        )
-                            .into_response();
-                    }
-                };
-
-                // convert JsValue -> JSON (Boa returns Option<Value>)
-                let result_json: Value = match result.to_json(&mut ctx) {
-                    Ok(Some(v)) => v,
-                    Ok(None) => serde_json::json!({ "error": "JS returned undefined" }),
-                    Err(e) => json_error(e.to_string()),
-                };
-
-                
-
-                return Json(result_json).into_response();
-            }
+    // read JS bundle
+    let js_code = match fs::read_to_string(action_path) {
+        Ok(v) => v,
+        Err(e) => {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Failed reading action bundle: {}", e),
+            )
+            .into_response();
+        }
+    };
+
+    // ---------------------------
+    // ENV injection (correct way)
+    // ---------------------------
+    let mut env_map = serde_json::Map::new();
+    for (k, v) in std::env::vars() {
+        env_map.insert(k, Value::String(v));
+    }
+
+    let env_json = serde_json::Value::Object(env_map);
+
+    // Final JS code to execute in Boa
+    let injected = format!(
+        r#"
+        globalThis.process = {{
+            env: {}
+        }};
+
+        const __titan_req = {};
+        {};
+
+        {}(__titan_req);
+        "#,
+        env_json.to_string(),
+        body_str,
+        js_code,
+        action_name
+    );
+
+    // Execute JS safely
+    let mut ctx = Context::default();
+    let result = match ctx.eval(Source::from_bytes(&injected)) {
+        Ok(v) => v,
+        Err(e) => {
+            return Json(json_error(e.to_string())).into_response();
+        }
+    };
+
+    // Convert Boa -> JSON
+    let result_json: Value = match result.to_json(&mut ctx) {
+        Ok(Some(v)) => v,
+        Ok(None) => serde_json::json!({ "error": "JS returned undefined" }),
+        Err(e) => json_error(e.to_string()),
+    };
+
+    return Json(result_json).into_response();
+}
 
             // --------------------------
             // STATIC JSON
@@ -154,11 +177,15 @@ fn json_error(msg: String) -> Value {
     serde_json::json!({ "error": msg })
 }
 
+
+
 // ----------------------
 // MAIN
 // ----------------------
 #[tokio::main]
 async fn main() -> Result<()> {
+    dotenvy::dotenv().ok();
+
     let raw = fs::read_to_string("./routes.json").unwrap_or_else(|_| "{}".to_string());
     let json: Value = serde_json::from_str(&raw).unwrap_or_default();
 
@@ -190,20 +217,15 @@ async fn main() -> Result<()> {
     //
     // TITAN BANNER
     //
-    println!(
-        "\n\x1b[38;5;208m\
-████████╗██╗████████╗ █████╗ ███╗   ██╗\n\
-╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║\n\
-   ██║   ██║   ██║   ███████║██╔██╗ ██║\n\
-   ██║   ██║   ██║   ██╔══██║██║╚██╗██║\n\
-   ██║   ██║   ██║   ██║  ██║██║ ╚████║\n\
-   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n"
-    );
+    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);
 
-    println!(
-        "\x1b[38;5;39mTitan server running at:\x1b[0m \x1b[97mhttp://localhost:{}\x1b[0m\n",
-        port
-    );
     axum::serve(listener, app).await?;
     Ok(())
 }

package/templates/titan/titan.js

@@ -1,5 +1,6 @@
 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`;
@@ -38,8 +39,15 @@ const t = {
     return addRoute("POST", route);
   },
 
-  start(port = 3000, msg = "") {
+  async start(port = 3000, msg = "") {
+
+
+    console.log(cyan("[Titan] Bundling actions..."));
+    await bundle();
+
     const base = path.join(process.cwd(), "server");
+    fs.mkdirSync(base, { recursive: true });
+
 
     fs.writeFileSync(
       path.join(base, "routes.json"),
@@ -52,6 +60,7 @@ const t = {
     );
 
     console.log(green(`Titan: routes.json + action_map.json written -> ${base}`));
+
     if (msg) console.log(cyan(msg));
   }
 };