@ezetgalaxy/titan 26.8.2 → 26.9.0

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

@@ -1,33 +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,
-    }
-}
-
-
+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/dev.js

@@ -3,7 +3,6 @@ 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);
@@ -39,12 +38,20 @@ function getTitanVersion() {
                 cur = path.join(cur, "..");
             }
         } catch (e2) { }
+
+        try {
+            // Fallback to calling tit --version
+            const output = execSync("tit --version", { encoding: "utf-8" }).trim();
+            const match = output.match(/v(\d+\.\d+\.\d+)/);
+            if (match) return match[1];
+        } catch (e3) { }
     }
     return "0.1.0";
 }
 
 let serverProcess = null;
 let isKilling = false;
+let isFirstBoot = true;
 
 // ... (killServer same as before) 
 async function killServer() {
@@ -156,7 +163,24 @@ async function startRustServer(retryCount = 0) {
                 isReady = true;
                 clearTimeout(slowTimer);
                 stopSpinner(true, "Your app is now orbiting Titan Planet");
-                process.stdout.write(stdoutBuffer);
+
+                if (isFirstBoot) {
+                    process.stdout.write(stdoutBuffer);
+                    isFirstBoot = false;
+                } else {
+                    // On subsequent reloads, only print non-banner lines from the buffer
+                    const lines = stdoutBuffer.split("\n");
+                    for (const line of lines) {
+                        const isBanner = line.includes("Titan server running") ||
+                            line.includes("████████╗") ||
+                            line.includes("╚══") ||
+                            line.includes("   ██║") ||
+                            line.includes("   ╚═╝");
+                        if (!isBanner && line.trim()) {
+                            process.stdout.write(line + "\n");
+                        }
+                    }
+                }
                 stdoutBuffer = "";
             }
         } else {
@@ -188,7 +212,7 @@ async function startRustServer(retryCount = 0) {
 async function rebuild() {
     try {
         execSync("node app/app.js", { stdio: "ignore" });
-        await bundle();
+        // bundle is called inside app.js (t.start)
     } catch (e) {
         stopSpinner(false, "Failed to prepare runtime");
         console.log(red(`[Titan] Error: ${e.message}`));
@@ -203,7 +227,15 @@ async function startDev() {
         hasRust = fs.readdirSync(actionsDir).some(f => f.endsWith(".rs"));
     }
 
-    const mode = hasRust ? "Rust + JS Actions" : "JS Actions";
+    const isTs = fs.existsSync(path.join(root, "tsconfig.json")) ||
+        fs.existsSync(path.join(root, "app", "app.ts"));
+
+    let mode = "";
+    if (hasRust) {
+        mode = isTs ? "Rust + TS Actions" : "Rust + JS Actions";
+    } else {
+        mode = isTs ? "TS Actions" : "JS Actions";
+    }
     const version = getTitanVersion();
 
     console.clear();
@@ -234,14 +266,6 @@ async function startDev() {
     watcher.on("all", async (event, file) => {
         if (timer) clearTimeout(timer);
         timer = setTimeout(async () => {
-            // console.log(""); 
-            /*
-            if (file.includes(".env")) {
-                console.log(yellow("[Titan] Env Refreshed"));
-            } else {
-                console.log(cyan(`[Titan] Change: ${path.basename(file)}`));
-            }
-            */
             try {
                 await killServer();
                 await rebuild();

package/templates/rust-ts/Dockerfile

@@ -0,0 +1,66 @@
+# ================================================================
+# STAGE 1 — Build Titan (JS → Rust)
+# ================================================================
+FROM rust:1.91.1 AS builder
+
+# Install Node for Titan CLI + bundler
+RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs
+
+# Install Titan CLI (latest)
+RUN npm install -g @ezetgalaxy/titan@latest
+
+WORKDIR /app
+
+# Copy project files
+COPY . .
+
+# Install JS dependencies (needed for Titan DSL + bundler)
+RUN npm install
+
+SHELL ["/bin/bash", "-c"]
+
+# Extract Titan extensions into .ext
+RUN mkdir -p /app/.ext && \
+    find /app/node_modules -maxdepth 5 -type f -name "titan.json" -print0 | \
+    while IFS= read -r -d '' file; do \
+    pkg_dir="$(dirname "$file")"; \
+    pkg_name="$(basename "$pkg_dir")"; \
+    echo "Copying Titan extension: $pkg_name from $pkg_dir"; \
+    cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
+    done && \
+    echo "Extensions in .ext:" && \
+    ls -R /app/.ext
+
+# Build Titan metadata + bundle JS actions
+RUN titan build
+
+# Build Rust binary
+RUN cd server && cargo build --release
+
+
+
+# ================================================================
+# STAGE 2 — Runtime Image (Lightweight)
+# ================================================================
+FROM debian:stable-slim
+
+WORKDIR /app
+
+# Copy Rust binary from builder stage
+COPY --from=builder /app/server/target/release/titan-server ./titan-server
+
+# Copy Titan routing metadata
+COPY --from=builder /app/server/routes.json ./routes.json
+COPY --from=builder /app/server/action_map.json ./action_map.json
+
+# Copy Titan JS bundles
+RUN mkdir -p /app/actions
+COPY --from=builder /app/server/actions /app/actions
+
+# Copy only Titan extensions
+COPY --from=builder /app/.ext ./.ext
+
+EXPOSE 3000
+
+CMD ["./titan-server"]

package/templates/rust-ts/_dockerignore

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

package/templates/rust-ts/_gitignore

@@ -0,0 +1,38 @@
+# Node & Packages
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+package-lock.json
+yarn.lock
+
+# Titan Runtime (Auto-generated - DO NOT COMMIT)
+titan/server-bin*
+.titan/
+.ext/
+server/routes.json
+server/action_map.json
+server/actions/
+server/titan/
+server/src/actions_rust/
+
+# Rust Build Artifacts
+server/target/
+Cargo.lock
+
+# OS Files
+.DS_Store
+Thumbs.db
+*.tmp
+*.bak
+
+# Environment & Secrets
+.env
+.env.local
+.env.*.local
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo

package/templates/rust-ts/app/actions/hello.ts

@@ -0,0 +1,5 @@
+export const hello = (req) => {
+   return {
+        message: `Hello from Titan ${req.body.name}`,
+    };
+}

package/templates/rust-ts/app/actions/rust_hello.rs

@@ -0,0 +1,14 @@
+use axum::{response::{IntoResponse, Json}, http::Request, body::Body};
+use serde_json::json;
+
+pub async fn run(_req: Request<Body>) -> impl IntoResponse {
+    // let _token = t.jwt.sign(json!({"id": 1}), "secret", Some(json!({"expiresIn": "1h"}))).unwrap_or_default();
+    // let decoded = t.jwt.verify(&_token, "secret").unwrap_or_default();
+
+    Json(json!({
+        "message": "Hello from Rust Action! 🦀",
+        "status": "blazing fast test",
+        // "token": _token,
+        // "decoded": decoded
+    }))
+}

package/templates/rust-ts/app/app.ts

@@ -0,0 +1,11 @@
+import t from "../titan/titan.js";
+
+
+
+
+t.post("/hello").action("hello") // pass a json payload { "name": "titan" }
+t.get("/rust").action("rust_hello") // This route uses a rust action
+
+t.get("/").reply("Ready to land on Titan Planet 🚀");
+
+t.start(3000, "Titan Running!");

package/templates/rust-ts/app/titan.d.ts

@@ -0,0 +1,101 @@
+export { };
+
+declare global {
+  /**
+   * TITAN TYPE DEFINITIONS
+   * ----------------------
+   * These types are globally available in your Titan project.
+   */
+
+  /**
+   * The Titan Request Object passed to actions.
+   */
+  interface TitanRequest {
+    body: any;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    headers: {
+      host?: string;
+      "content-type"?: string;
+      "user-agent"?: string;
+      authorization?: string;
+      [key: string]: string | undefined;
+    };
+    params: Record<string, string>;
+    query: Record<string, string>;
+  }
+
+  interface DbConnection {
+    /**
+     * Execute a SQL query.
+     * @param sql The SQL query string.
+     * @param params (Optional) Parameters for the query ($1, $2, etc).
+     */
+    query(sql: string, params?: any[]): any[];
+  }
+
+  /**
+   * Define a Titan Action with type inference.
+   * @example
+   * export const hello = defineAction((req) => {
+   *   return req.headers;
+   * });
+   */
+  function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+  /**
+   * Titan Runtime Utilities
+   */
+  const t: {
+    /**
+     * Log messages to the server console with Titan formatting.
+     */
+    log(...args: any[]): void;
+
+    /**
+     * Read a file contents as string.
+     * @param path Relative path to the file from project root.
+     */
+    read(path: string): string;
+
+    fetch(url: string, options?: {
+      method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+      headers?: Record<string, string>;
+      body?: string | object;
+    }): {
+      ok: boolean;
+      status?: number;
+      body?: string;
+      error?: string;
+    };
+
+    jwt: {
+      sign(
+        payload: object,
+        secret: string,
+        options?: { expiresIn?: string | number }
+      ): string;
+      verify(token: string, secret: string): any;
+    };
+
+    password: {
+      hash(password: string): string;
+      verify(password: string, hash: string): boolean;
+    };
+
+    db: {
+      connect(url: string): DbConnection;
+    };
+
+    /**
+     * Titan Validator (Zod-compatible)
+     */
+    valid: typeof import("@titanpl/valid");
+  };
+
+  /**
+   * Global Request Object
+   * Available automatically in actions.
+   */
+  var req: TitanRequest;
+}

package/templates/rust-ts/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "titanpl",
+  "version": "1.0.0",
+  "description": "A Titan Planet server (Rust + TypeScript)",
+  "type": "module",
+  "titan": {
+    "template": "rust-ts"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "esbuild": "^0.27.2",
+    "typescript": "^5.0.0"
+  }
+}