@t8n/ui 1.0.0

package/test-app/app/titan.d.ts

@@ -0,0 +1,249 @@
+
+// -- Module Definitions (for imports from "titan") --
+
+export interface RouteHandler {
+    reply(value: any): void;
+    action(name: string): void;
+}
+
+export interface TitanBuilder {
+    get(route: string): RouteHandler;
+    post(route: string): RouteHandler;
+    log(module: string, msg: string): void;
+    start(port?: number, msg?: string): Promise<void>;
+}
+
+declare const builder: TitanBuilder;
+export const Titan: TitanBuilder;
+export default builder;
+
+export declare function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+// -- Global Definitions (Runtime Environment) --
+
+/**
+ * # Drift - Orchestration Engine
+ * 
+ * Revolutionary system for high-performance asynchronous operations using a **Deterministic Replay-based Suspension** model.
+ * 
+ * ## Mechanism
+ * Drift utilizes a suspension model similar to **Algebraic Effects**. When a `drift()` operation is encountered, 
+ * the runtime suspends the isolate, offloads the task to the background Tokio executor, and frees the isolate 
+ * to handle other requests. Upon completion, the code is efficiently **re-played** with the result injected.
+ * 
+ * @param promise - The promise or expression to drift.
+ * @returns The resolved value of the input promise.
+ * 
+ * @example
+ * ```javascript
+ * const resp = drift t.fetch("http://api.titan.com");
+ * ```
+ */
+declare var drift: <T>(promise: Promise<T> | T) => T;
+
+declare global {
+    /**
+     * Titan Global Drift
+     */
+    var drift: <T>(promise: Promise<T> | T) => T;
+
+    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 {
+        query(sql: string, params?: any[]): any[];
+    }
+
+    function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+    var req: TitanRequest;
+
+    interface TitanRuntimeUtils {
+        log(...args: any[]): void;
+        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` (Database Connection) */
+        db: {
+            connect(url: string): DbConnection;
+        };
+
+        /** ### `fs` (File System) */
+        fs: TitanCore.FileSystem;
+
+        /** ### `path` (Path Manipulation) */
+        path: TitanCore.Path;
+
+        /** ### `crypto` (Cryptography) */
+        crypto: TitanCore.Crypto;
+
+        /** ### `buffer` (Buffer Utilities) */
+        buffer: TitanCore.BufferModule;
+
+        /** ### `ls` / `localStorage` (Persistent Storage) */
+        ls: TitanCore.LocalStorage;
+        localStorage: TitanCore.LocalStorage;
+
+        /** ### `session` (Server-side Sessions) */
+        session: TitanCore.Session;
+
+        /** ### `cookies` (HTTP Cookies) */
+        cookies: TitanCore.Cookies;
+
+        /** ### `os` (Operating System) */
+        os: TitanCore.OS;
+
+        /** ### `net` (Network) */
+        net: TitanCore.Net;
+
+        /** ### `proc` (Process) */
+        proc: TitanCore.Process;
+
+        /** ### `time` (Time) */
+        time: TitanCore.Time;
+
+        /** ### `url` (URL) */
+        url: TitanCore.URLModule;
+
+        /** ### `response` (HTTP Response Builder) */
+        response: TitanCore.ResponseModule;
+
+        valid: any;
+        [key: string]: any;
+    }
+
+    const t: TitanRuntimeUtils;
+    const Titan: TitanRuntimeUtils;
+
+    namespace TitanCore {
+        interface FileSystem {
+            readFile(path: string): string;
+            writeFile(path: string, content: string): void;
+            readdir(path: string): string[];
+            mkdir(path: string): void;
+            exists(path: string): boolean;
+            stat(path: string): { size: number, isFile: boolean, isDir: boolean, modified: number };
+            remove(path: string): void;
+        }
+
+        interface Path {
+            join(...args: string[]): string;
+            resolve(...args: string[]): string;
+            extname(path: string): string;
+            dirname(path: string): string;
+            basename(path: string): string;
+        }
+
+        interface Crypto {
+            hash(algorithm: 'sha256' | 'sha512' | 'md5', data: string): string;
+            randomBytes(size: number): string;
+            uuid(): string;
+            compare(hash: string, target: string): boolean;
+            encrypt(algorithm: string, key: string, plaintext: string): string;
+            decrypt(algorithm: string, key: string, ciphertext: string): string;
+            hashKeyed(algorithm: 'hmac-sha256' | 'hmac-sha512', key: string, message: string): string;
+        }
+
+        interface BufferModule {
+            fromBase64(str: string): Uint8Array;
+            toBase64(bytes: Uint8Array | string): string;
+            fromHex(str: string): Uint8Array;
+            toHex(bytes: Uint8Array | string): string;
+            fromUtf8(str: string): Uint8Array;
+            toUtf8(bytes: Uint8Array): string;
+        }
+
+        interface LocalStorage {
+            get(key: string): string | null;
+            set(key: string, value: string): void;
+            remove(key: string): void;
+            clear(): void;
+            keys(): string[];
+        }
+
+        interface Session {
+            get(sessionId: string, key: string): string | null;
+            set(sessionId: string, key: string, value: string): void;
+            delete(sessionId: string, key: string): void;
+            clear(sessionId: string): void;
+        }
+
+        interface Cookies {
+            get(req: any, name: string): string | null;
+            set(res: any, name: string, value: string, options?: any): void;
+            delete(res: any, name: string): void;
+        }
+
+        interface OS {
+            platform(): string;
+            cpus(): number;
+            totalMemory(): number;
+            freeMemory(): number;
+            tmpdir(): string;
+        }
+
+        interface Net {
+            resolveDNS(hostname: string): string[];
+            ip(): string;
+            ping(host: string): boolean;
+        }
+
+        interface Process {
+            pid(): number;
+            uptime(): number;
+            memory(): Record<string, any>;
+        }
+
+        interface Time {
+            sleep(ms: number): void;
+            now(): number;
+            timestamp(): string;
+        }
+
+        interface URLModule {
+            parse(url: string): any;
+            format(urlObj: any): string;
+            SearchParams: any;
+        }
+
+        interface ResponseModule {
+            (options: any): any;
+            text(content: string, status?: number): any;
+            html(content: string, status?: number): any;
+            json(content: any, status?: number): any;
+            redirect(url: string, status?: number): any;
+            empty(status?: number): any;
+        }
+    }
+}

package/test-app/eslint.config.js

@@ -0,0 +1,8 @@
+import { titanpl } from 'eslint-plugin-titanpl';
+
+export default [
+  {
+    ignores: ['**/*.d.ts']
+  },
+  titanpl
+];

package/test-app/jsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "checkJs": false,
+        "noImplicitAny": false,
+        "allowJs": true,
+        "moduleResolution": "node",
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "./app/*"
+            ]
+        }
+    },
+    "include": [
+        "app/**/*",
+        "titan/**/*"
+    ]
+}

package/test-app/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "titanpl",
+  "version": "1.0.0",
+  "description": "A Titan Planet server",
+  "type": "module",
+  "titan": {
+    "template": "js"
+  },
+  "dependencies": {
+    "@titanpl/core": "latest",
+    "chokidar": "^5.0.0",
+    "esbuild": "^0.27.2"
+  },
+  "scripts": {
+    "build": "titan build",
+    "dev": "titan dev",
+    "start": "titan start",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.2",
+    "eslint-plugin-titanpl": "^1.0.0"
+  }
+}

package/test-app/server/Cargo.toml

@@ -0,0 +1,32 @@
+
+[package]
+name = "titan-server"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+axum = "0.8.7"
+dotenv = "0.15.0"
+reqwest = { version = "0.12.24", features = ["json", "rustls-tls", "gzip", "brotli", "blocking"] }
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = "1.0.145"
+thiserror = "2.0.17"
+tokio = { version = "1.48.0", features = ["rt-multi-thread", "macros", "process"] }
+tower-http = { version = "0.6.7", features = ["cors"] }
+tracing = "0.1.43"
+tracing-subscriber = "0.3.22"
+anyhow = "1"
+v8 = "0.106.0"
+dotenvy = "0.15"
+base64 = "0.21"
+regex = "1.10"
+bcrypt = "0.15"
+jsonwebtoken = "9"
+postgres = { version = "0.19", features = ["with-serde_json-1"] }
+libloading = "0.8"
+walkdir = "2"
+crossbeam = "0.8.4"
+dashmap = "6.1.0"
+bytes = "1.11.0"
+smallvec = "1.15.1"
+num_cpus = "1.17.0"

package/test-app/server/src/action_management.rs

@@ -0,0 +1,171 @@
+use std::collections::HashMap;
+use std::env;
+use std::path::{Path, PathBuf};
+use serde::Deserialize;
+use serde_json::Value;
+
+/// Route configuration (loaded from routes.json)
+#[derive(Debug, Deserialize, Clone)]
+pub struct RouteVal {
+    pub r#type: String,
+    #[serde(alias = "target")]
+    pub value: Value,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct DynamicRoute {
+    pub method: String,
+    pub pattern: String,
+    pub action: String,
+}
+
+// -------------------------
+// ACTION DIRECTORY RESOLUTION
+// -------------------------
+
+pub fn resolve_actions_dir() -> PathBuf {
+    // Respect explicit override first
+    if let Ok(override_dir) = env::var("TITAN_ACTIONS_DIR") {
+        return PathBuf::from(override_dir);
+    }
+
+    // Production container layout
+    if Path::new("/app/actions").exists() {
+        return PathBuf::from("/app/actions");
+    }
+
+    // Try to walk up from the executing binary to discover `<...>/server/actions`
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(parent) = exe.parent() {
+            if let Some(target_dir) = parent.parent() {
+                if let Some(server_dir) = target_dir.parent() {
+                    let candidate = server_dir.join("actions");
+                    if candidate.exists() {
+                        return candidate;
+                    }
+                }
+            }
+        }
+    }
+
+    // Fall back to local ./actions
+    PathBuf::from("./actions")
+}
+
+/// Try to find the directory that contains compiled action bundles.
+pub fn find_actions_dir(project_root: &PathBuf) -> Option<PathBuf> {
+    let candidates = [
+        project_root.join("app").join("actions"),
+        project_root.join("actions"),
+        project_root.join("server").join("actions"),
+        project_root.join("..").join("server").join("actions"),
+        PathBuf::from("/app").join("actions"),
+        PathBuf::from("actions"),
+    ];
+
+    for p in &candidates {
+        if p.exists() && p.is_dir() {
+            return Some(p.clone());
+        }
+    }
+
+    None
+}
+
+// Dynamic Matcher (Core Logic)
+
+pub fn match_dynamic_route(
+    method: &str,
+    path: &str,
+    routes: &[DynamicRoute],
+) -> Option<(String, HashMap<String, String>)> {
+    let path_segments: Vec<&str> =
+        path.trim_matches('/').split('/').collect();
+
+    for route in routes {
+        if route.method != method {
+            continue;
+        }
+
+        let pattern_segments: Vec<&str> =
+            route.pattern.trim_matches('/').split('/').collect();
+
+        if pattern_segments.len() != path_segments.len() {
+            continue;
+        }
+
+        let mut params = HashMap::new();
+        let mut matched = true;
+
+        for (pat, val) in pattern_segments.iter().zip(path_segments.iter()) {
+            if pat.starts_with(':') {
+                let inner = &pat[1..];
+
+                let (name, ty) = inner
+                    .split_once('<')
+                    .map(|(n, t)| (n, t.trim_end_matches('>')))
+                    .unwrap_or((inner, "string"));
+
+                let valid = match ty {
+                    "number" => val.parse::<i64>().is_ok(),
+                    "string" => true,
+                    _ => false,
+                };
+
+                if !valid {
+                    matched = false;
+                    break;
+                }
+
+                params.insert(name.to_string(), (*val).to_string());
+            } else if pat != val {
+                matched = false;
+                break;
+            }
+        }
+
+        if matched {
+            return Some((route.action.clone(), params));
+        }
+    }
+
+    None
+}
+
+// -------------------------
+// ACTION SCANNING
+// -------------------------
+
+pub fn scan_actions(root: &PathBuf) -> HashMap<String, PathBuf> {
+    let mut map = HashMap::new();
+    
+    // Locate actions dir
+    let actions_dir = resolve_actions_dir();
+    let dir = if actions_dir.exists() {
+        actions_dir
+    } else {
+        match find_actions_dir(root) {
+            Some(d) => d,
+            None => return map, 
+        }
+    };
+
+    if let Ok(entries) = std::fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if !path.is_file() { continue; }
+            
+            let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("");
+            if ext != "js" && ext != "jsbundle" {
+                continue;
+            }
+            
+            let file_stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
+            if file_stem.is_empty() { continue; }
+            
+            map.insert(file_stem.to_string(), path);
+        }
+    }
+    
+    map
+}

package/test-app/server/src/errors.rs

@@ -0,0 +1,10 @@
+use v8::JsError;
+
+// A helper to Format v8 Errors
+pub fn format_js_error(err: JsError, action: &str) -> String {
+    format!(
+        "Action: {}\n{}",
+        action,
+        err.to_string()
+    )
+}