@ezetgalaxy/titan 25.12.2 → 25.12.3

package/README.md

@@ -1,31 +1,61 @@
-***
+# TITAN PLANET 🚀
 
-## TITAN PLANET 🚀  
 JavaScript Simplicity. Rust Power.
 
-Titan is a JavaScript-first backend framework that compiles your JS routes and actions into a production-grade **Rust + Axum native server**.
+Titan is a JavaScript-first backend framework that compiles your JavaScript routes and actions into a production-grade **Rust + Axum native server**.
 
-Developers write **zero Rust**, yet deploy a high-performance, safe, fully native backend with excellent DX (developer experience).
+Developers write **zero Rust**, yet deploy a high-performance, safe, fully native backend with modern DX.
 
-Titan = Next.js DX × Rust performance × JavaScript simplicity
+Titan = Rust performance × JavaScript simplicity
 
 ---
 
-## ⚙ Requirements
+# 🐳 Production Docker Support (Pre-built by Titan CLI)
 
-Before using Titan, ensure your system has:
+Titan provides **first-class Docker support automatically**.
 
-### **1. Rust (latest stable)**
-Install from:
-https://rust-lang.org/tools/install/
+When you create a project with:
+
+```bash
+tit init my-app
+```
+
+Titan generates:
+
+* A **pre-configured Dockerfile** (production-ready)
+* A **pre-configured .dockerignore**
+* A **Git-ready .gitignore**
+* A **safe, no-spaces directory structure** ideal for cloud builds
+
+You do **not** need to modify the Dockerfile. It is optimized for:
+
+* Native Rust builds
+* Fast multi-stage compilation
+* Minimal final image size
+* Railway, Fly.io, Render, Docker Hub, VPS deployments
+
+This ensures **zero-config deployment** anywhere.
+
+---
+
+# ⚙ Requirements
+
+Install before using Titan:
+
+### 1. Rust (latest stable)
+
+[https://rust-lang.org/tools/install/](https://rust-lang.org/tools/install/)
+
+### 2. Node.js (v18+)
 
-### **2. Node.js (v18+)**
 Required for:
-- Titan CLI  
-- esbuild  
-- JS → Rust compilation process  
 
-Check version:
+* Titan CLI
+* esbuild
+* JS → Rust compilation pipeline
+
+Verify:
+
 ```bash
 node -v
 npm -v
@@ -34,30 +64,61 @@ rustc -V
 
 ---
 
-## New Features
-  To get new features:
-  ```bash
-  tit update
-  ```
-
-## ✨ Features
-
-- Write your backend in **pure JavaScript**
-- Compile into a **native Rust HTTP server**
-- Titan DSL: `t.get()`, `t.post()`, `t.start()`
-- Automatic **route generation**
-- Automatic **JS action bundling**
-- Fast **Rust Axum runtime**
-- JavaScript execution via **Boa engine**
-- **Hot Reload Dev Server** (edit → rebuild → restart automatically)
-- Production output: **single binary**
-- Zero-config deployment
+# 🔄 Updating Titan CLI
+
+Titan ships with a built-in updater.
+To upgrade to the latest CLI, features, and patches:
+
+```bash
+tit update
+```
+
+This updates:
+
+* Titan CLI
+* DSL components
+* Bundler + Dev server
+* Rust server templates
+* Dockerfile (if version bump requires)
+
+Backwards compatibility is maintained automatically.
+
+---
+
+# ✨ Features
+
+Here is the updated **Features** block with your new environment-variable feature added cleanly and professionally, matching the style of your documentation.
+
+You can copy–paste it directly into the README.
 
 ---
 
-## 📦 Installation
+# ✨ Features
+
+* Write backend logic in **pure JavaScript**
+* Compile into a **native Rust Axum server**
+* Titan DSL: `t.get()`, `t.post()`, `t.start()`
+* Automatic **route generation**
+* Automatic **JS action bundling**
+* High-performance **Rust Axum runtime**
+* JavaScript execution via **Boa engine**
+* Full **Hot Reload Dev Server**
+* **Single binary** production output
+* Zero-config deployment
+* Built-in **environment variable support** — create a `.env` file in the project root and access values directly via `process.env.KEY_NAME` inside your Titan actions and app logic
 
-Install the Titan CLI globally:
+With `.env` support, Titan loads environment variables automatically during:
+
+* `tit dev`
+* `tit build`
+* Production runtime inside the Rust server
+
+No additional configuration is required.
+
+
+---
+
+# 📦 Installation
 
 ```bash
 npm install -g @ezetgalaxy/titan
@@ -65,7 +126,7 @@ npm install -g @ezetgalaxy/titan
 
 ---
 
-## 🚀 Create a New Titan Project
+# 🚀 Create a New Titan Project
 
 ```bash
 tit init my-app
@@ -73,12 +134,12 @@ cd my-app
 tit dev
 ```
 
-Titan will automatically:
+Titan will:
 
-- Create project structure  
-- Generate routes from `/app/app.js`  
-- Bundle JS actions into `.jsbundle` files  
-- Start the **Rust Axum dev server with Hot Reload**  
+* Create the project structure
+* Generate routing metadata
+* Bundle JS actions
+* Start the Rust dev server with hot reload
 
 ---
 
@@ -86,30 +147,36 @@ Titan will automatically:
 
 ```
 my-app/
-├── app/
-│   ├── app.js                 # Titan routes (DSL)
-│   └── actions/
-│       └── hello.js           # Titan action
-│
-├── titan/
-│   ├── titan.js               # Titan DSL
-│   ├── bundle.js              # Bundler (esbuild)
-│   └── dev.js                 # Hot reload engine
+├── app/                                  # You develop ONLY this folder
+│   ├── app.js                             # Titan routes (DSL)
+│   └── actions/                           # Your custom JS actions
+│       └── hello.js                       # Example Titan action
+
+───────────────────────────────────────────────────────────────
+  Everything below is auto-generated by `tit init`
+  You never modify these folders manually
+───────────────────────────────────────────────────────────────
+
+├── titan/                                # Titan's internal JS engine
+│   ├── titan.js                           # Titan DSL runtime
+│   ├── bundle.js                          # JS → .jsbundle bundler
+│   └── dev.js                             # Hot Reload system
 │
-├── server/                    # Rust backend (auto generated)
-│   ├── src/
-│   ├── actions/               # JS → .jsbundle compiled actions
-│   ├── titan/                 # internal runtime files
-│   ├── target/                # Cargo build output
-│   ├── routes.json
-│   ├── action_map.json
-│   └── titan-server           # Final Rust binary
+├── server/                               # Auto-generated Rust backend
+│   ├── Cargo.toml                         # Rust project config
+│   ├── src/                               # Rust source code
+│   ├── actions/                           # Compiled .jsbundle actions
+│   ├── titan/                             # Internal Rust runtime files
+│   ├── routes.json                        # Generated route metadata
+│   ├── action_map.json                    # Maps actions to bundles
+│   └── titan-server                       # Final production Rust binary
 │
-└── package.json
-```
+├── Dockerfile                             # Auto-generated production Dockerfile
+├── .dockerignore                          # Auto-generated Docker ignore rules
+├── package.json                           # JS project config (auto)
+└── .gitignore                             # Auto-generated by `tit init`
 
-This is the complete Titan architecture:  
-**JS input → Rust server output → Native production binary.**
+```
 
 ---
 
@@ -127,58 +194,40 @@ globalThis.hello = hello;
 
 ---
 
-# 🛣 Example: Titan Routes (DSL)
+# 🛣 Example: Routes (Titan DSL)
 
 **app/app.js**
 
 ```js
 import t from "../titan/titan.js";
 
-// POST /hello → hello action
 t.post("/hello").action("hello");
-
-// GET / → reply text
 t.get("/").reply("Welcome to Titan");
 
 t.start(3000, "Ready to land on Titan Planet 🚀");
 ```
 
-Titan generates:
-
-- `server/routes.json`
-- `server/action_map.json`
-
-Used by the Rust runtime to dispatch requests.
-
 ---
 
 # 🔥 Hot Reload Dev Mode
 
-Start development mode:
-
 ```bash
 tit dev
 ```
 
-Titan Dev Mode will:
+Titan Dev Mode:
 
-- Regenerate routes on every save  
-- Rebundle actions automatically  
-- **Kill and restart the Rust server safely**  
-- Give full hot reload like modern JS frameworks  
+* Rebuilds routes automatically
+* Rebundles actions
+* Restarts Rust server safely
+* Provides instant backend hot reload
 
-Full DX flow:
+Flow:
 
 ```
-Save file → auto rebuild → auto restart → updated API
+Save → Rebuild → Restart → Updated API
 ```
 
-Supports:
-
-- Editing `app/app.js`
-- Editing `app/actions/*.js`
-- Fast rebuilds via esbuild
-
 ---
 
 # 🏭 Production Build
@@ -187,7 +236,7 @@ Supports:
 tit build
 ```
 
-Production output goes into:
+Production output:
 
 ```
 server/
@@ -197,76 +246,113 @@ server/
   actions/*.jsbundle
 ```
 
-You deploy **only the server folder**.
-
 ---
 
-# ☁ Deploying Titan
+# ☁ Uploading Titan to GitHub
 
-After `tit build`, deploy the `server/` folder anywhere:
+Titan projects are designed for **direct repository upload**.
 
-- Railway  
-- Fly.io  
-- Docker  
-- VPS  
-- Render  
-- Bare metal  
+Include everything generated by `tit init`:
+
+```
+app/
+titan/
+server/
+Cargo.toml
+Dockerfile
+.gitignore
+package.json
+```
 
-Start command:
+Push to GitHub:
 
 ```bash
-./titan-server
+git init
+git add .
+git commit -m "Initial Titan project"
+git branch -M main
+git remote add origin <your_repo_url>
+git push -u origin main
 ```
 
-No Node.js needed in production — Titan runs as a pure Rust binary.
+Your repo is now fully deployable with Docker.
 
 ---
 
-# 🧠 How Titan Works (Internals)
+# ☁ Zero-Config Deployment with Docker
 
-### 1. JavaScript DSL  
-You write backend logic using Titan’s intuitive DSL.
+Once pushed to GitHub, you can deploy anywhere.
 
-### 2. Bundler  
-Titan uses esbuild to compile JS actions into `.jsbundle`.
+## Deploy to Railway
 
-### 3. Metadata  
-`t.start()` writes:
+1. Go to Railway
+2. Create New Project → Deploy from GitHub
+3. Select your Titan repo
+4. Railway auto-detects the Dockerfile
+5. It builds + deploys automatically
 
-- `routes.json`
-- `action_map.json`
+Railway will:
 
-### 4. Rust Server  
-Axum server:
+* Build your Rust server
+* Copy JS bundles
+* Start the `titan-server` binary
+* Expose the correct port
 
-- Loads `.jsbundle` actions  
-- Injects request data  
-- Executes JS via Boa  
-- Returns JSON response to user  
+No configuration required.
 
-### 5. Production Output  
-Titan produces:
+---
+
+# 🧠 Internal Architecture
+
+### 1. Titan DSL
+
+Simple JavaScript syntax for writing routes and actions.
+
+### 2. Bundler (esbuild)
+
+Compiles actions into `.jsbundle` format.
+
+### 3. Metadata
+
+`t.start()` generates:
+
+* `routes.json`
+* `action_map.json`
 
-- A **native binary**  
-- JS bundles  
-- Route maps  
-- Entire backend in one folder  
+### 4. Rust Server
+
+Axum-based runtime:
+
+* Loads JS bundles
+* Injects request objects
+* Executes JS via Boa
+* Returns JSON
+
+### 5. Production Output
+
+Titan emits:
+
+* Native Rust binary
+* JS bundles
+* Routing metadata
+* Fully deployable directory
 
 ---
 
 # 🎯 Why Titan Exists
 
-Titan exists for developers who want:
+Titan is for developers who want:
 
-- Rust performance  
-- JavaScript simplicity  
-- Zero Rust learning curve  
-- Zero config deployment  
-- Modern DX + native speed  
+* Rust performance
+* JavaScript simplicity
+* Zero Rust learning curve
+* Modern DX
+* Fast deployment
+* Native backend speed
 
-Titan bridges two worlds:
+Titan merges two worlds:
 
-**JavaScript Productivity × Rust Performance**
+JavaScript productivity × Rust performance.
 
 ---
 
@@ -274,18 +360,21 @@ Titan bridges two worlds:
 
 **Titan v1 — Stable**
 
-- JS → Rust server compiler  
-- Action Engine  
-- Axum Runtime  
-- Titan DSL  
-- Hot Reload Dev Mode  
-- Railway/Fly.io Deployment  
+Includes:
+
+* JS → Rust compiler
+* Action Engine
+* Axum Runtime
+* Titan DSL
+* Hot Reload Dev Server
+* Docker Deployments
+* Railway/Fly.io Support
+* `tit update` CLI Upgrader
 
 ---
 
 # 🤝 Contributing
 
-PRs, issues, suggestions, and feature discussions are welcome.
-
-***
+Issues, discussions, and pull requests are welcome.
 
+---

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";
@@ -221,7 +221,9 @@ function startProd() {
 function updateTitan() {
     const projectRoot = process.cwd();
     const projectTitan = path.join(projectRoot, "titan");
-    const cliTitan = path.join(__dirname, "templates", "titan");
+
+    const cliTemplatesRoot = path.join(__dirname, "templates");
+    const cliTitan = path.join(cliTemplatesRoot, "titan");
 
     if (!fs.existsSync(projectTitan)) {
         console.log(red("No titan/ folder found in this project."));
@@ -229,18 +231,41 @@ function updateTitan() {
         return;
     }
 
-    console.log(cyan("Titan: Updating runtime files..."));
 
-    const backupDir = path.join(projectRoot, `titan_backup_${Date.now()}`);
-    fs.renameSync(projectTitan, backupDir);
-    console.log(green(`✔ Backup created → ${backupDir}`));
+    //
+    // 2. Replace titan/ runtime folder
+    //
+    fs.rmSync(projectTitan, { recursive: true, force: true });
+    console.log(green("✔ Old titan/ runtime removed"));
 
     copyDir(cliTitan, projectTitan);
+    console.log(green("✔ titan/ runtime updated"));
+
+    //
+    // 3. Update server/Cargo.toml
+    //
+    const srcToml = path.join(cliTemplatesRoot, "server", "Cargo.toml");
+    const destToml = path.join(projectRoot, "server", "Cargo.toml");
+    if (fs.existsSync(srcToml)) {
+        fs.copyFileSync(srcToml, destToml);
+        console.log(green("✔ Updated server/Cargo.toml"));
+    }
 
-    const projectTemplateRoot = path.join(__dirname, "templates");
+    //
+    // 4. Update ONLY server/src/main.rs
+    //
+    const srcMain = path.join(cliTemplatesRoot, "server", "src", "main.rs");
+    const destMain = path.join(projectRoot, "server", "src", "main.rs");
+    if (fs.existsSync(srcMain)) {
+        fs.copyFileSync(srcMain, destMain);
+        console.log(green("✔ Updated server/src/main.rs"));
+    }
 
+    //
+    // 5. Update root-level config files
+    //
     [".gitignore", ".dockerignore", "Dockerfile"].forEach((file) => {
-        const src = path.join(projectTemplateRoot, file);
+        const src = path.join(cliTemplatesRoot, file);
         const dest = path.join(projectRoot, file);
 
         if (fs.existsSync(src)) {
@@ -249,12 +274,14 @@ function updateTitan() {
         }
     });
 
-    console.log(green("✔ Titan runtime updated successfully!"));
-    console.log(cyan("Your project now has the latest Titan features."));
+    console.log(cyan("✔ Titan forced update complete"));
 }
 
 
 
+
+
+
 // ROUTER
 switch (cmd) {
     case "init":

package/package.json

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

package/templates/titan/bundle.js

@@ -1,40 +1,40 @@
-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"));
-
-  for (const file of files) {
-    const entry = path.join(actionsDir, file);
-
-    // Rust runtime expects `.jsbundle` extension — consistent with previous design
-    const outfile = path.join(outDir, file.replace(".js", ".jsbundle"));
-
-    console.log(`[Titan] Bundling ${entry} → ${outfile}`);
-
-    await esbuild.build({
-      entryPoints: [entry],
-      bundle: true,
-      format: "cjs",
-      platform: "neutral",
-      outfile,
-      minify: false,
-    });
-  }
-
-  console.log("[Titan] Bundling finished.");
-}
+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"));
+
+  for (const file of files) {
+    const entry = path.join(actionsDir, file);
+
+    // Rust runtime expects `.jsbundle` extension — consistent with previous design
+    const outfile = path.join(outDir, file.replace(".js", ".jsbundle"));
+
+    console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+
+    await esbuild.build({
+      entryPoints: [entry],
+      bundle: true,
+      format: "cjs",
+      platform: "neutral",
+      outfile,
+      minify: false,
+    });
+  }
+
+  console.log("[Titan] Bundling finished.");
+}

package/templates/titan/dev.js

@@ -1,67 +1,67 @@
-import chokidar from "chokidar";
-import { spawn, execSync } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
-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;
-
-function startRustServer() {
-    if (serverProcess) {
-        serverProcess.kill();
-    }
-
-    const serverPath = path.join(process.cwd(), "server");
-
-    serverProcess = spawn("cargo", ["run"], {
-        cwd: serverPath,
-        stdio: "inherit",
-        shell: true
-    });
-
-    serverProcess.on("close", (code) => {
-        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...");
-
-    // FIRST BUILD
-    await rebuild();
-    startRustServer();
-
-    const watcher = chokidar.watch("app", {
-        ignoreInitial: true
-    });
-
-    let timer = null;
-
-    watcher.on("all", async (event, file) => {
-        if (timer) clearTimeout(timer);
-
-        timer = setTimeout(async () => {
-            console.log(`[Titan] Change detected: ${file}`);
-
-            await rebuild();
-
-            console.log("[Titan] Restarting Rust server...");
-            startRustServer();
-
-        }, 200);
-    });
-}
-
-startDev();
+import chokidar from "chokidar";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+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;
+
+function startRustServer() {
+    if (serverProcess) {
+        serverProcess.kill();
+    }
+
+    const serverPath = path.join(process.cwd(), "server");
+
+    serverProcess = spawn("cargo", ["run"], {
+        cwd: serverPath,
+        stdio: "inherit",
+        shell: true
+    });
+
+    serverProcess.on("close", (code) => {
+        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...");
+
+    // FIRST BUILD
+    await rebuild();
+    startRustServer();
+
+    const watcher = chokidar.watch("app", {
+        ignoreInitial: true
+    });
+
+    let timer = null;
+
+    watcher.on("all", async (event, file) => {
+        if (timer) clearTimeout(timer);
+
+        timer = setTimeout(async () => {
+            console.log(`[Titan] Change detected: ${file}`);
+
+            await rebuild();
+
+            console.log("[Titan] Restarting Rust server...");
+            startRustServer();
+
+        }, 200);
+    });
+}
+
+startDev();