@ezetgalaxy/titan 26.9.0 → 26.9.1

package/README.md

@@ -76,7 +76,7 @@ titan dev
 
 You'll see the Titan Dev Server spin up:
 ```
-  Titan Planet   v26.9.0   [ Dev Mode ]
+  Titan Planet   v26.9.1   [ Dev Mode ]
 
   Type:        Rust + TS Actions
   Hot Reload:  Enabled
@@ -93,34 +93,45 @@ You'll see the Titan Dev Server spin up:
 
 Titan is unique because it allows you to write endpoints in **JavaScript, TypeScript, and Rust** within the same project.
 
+| Feature | Status | Notes |
+| :--- | :--- | :--- |
+| **Standard JavaScript** | ✅ Stable | Production Ready |
+| **Standard TypeScript** | 🚧 Beta | **Ready for Dev**, Production Under Testing |
+| **Rust + JS (Hybrid)** | 🧪 Experimental | **Dev Only**, Production Under Testing |
+| **Rust + TS (Hybrid)** | 🧪 Experimental | **Dev Only**, Production Under Testing |
+
 ### 🔵 TypeScript Actions (`app/actions/hello.ts`)
 Fully typed, strict, and auto-compiled.
+
 ```typescript
-import { Context } from '@ezetgalaxy/titan';
+import { defineAction } from "../../titan/titan";
+
+interface HelloResponse {
+    message: string;
+    user_name: string;
+}
 
-export function run(req: Context) {
+// "defineAction" provides automatic type inference for "req"
+export const hello = defineAction((req): HelloResponse => {
     t.log("Handling request with strict types...");
-    
-    // Type checking allows safe property access
-    const user = req.body as { name: string };
-    
+
     return { 
         message: "Hello from TypeScript!",
-        user_name: user.name 
+        user_name: req.body.name || "Guest"
     };
-}
+});
 ```
 
 ### 🟡 JavaScript Actions (`app/actions/hello.js`)
 Perfect for business logic, rapid prototyping, and IO-bound tasks.
 ```javascript
-export function run(req) {
+export const hello = defineAction((req) => {
     t.log("Handling user request...");
     return { 
         message: "Hello from JavaScript!",
         user_id: req.params.id 
     };
-}
+});
 ```
 
 ### 🔴 Rust Actions (Beta)
@@ -212,4 +223,3 @@ Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript
 * Strict TypeScript Support
 * Native Rust Performance
 * Zero-Config Cloud Deployment
-

package/index.js

@@ -107,7 +107,7 @@ function help() {
     console.log(`
 ${bold(cyan("Titan Planet"))}  v${TITAN_VERSION}
 
-${green("titan init <project>")}   Create new Titan project
+${green("titan init <project> [-t <template>]")}   Create new Titan project
 ${green("titan create ext <name>")} Create new Titan extension
 ${green("titan dev")}              Dev mode (hot reload)
 ${green("titan build")}            Build production Rust server
@@ -188,7 +188,7 @@ async function initProject(name, templateName) {
         const arch = archRes.value;
 
         if (lang === 'js') {
-            selectedTemplate = arch === 'standard' ? 'js' : 'rust';
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust-js';
         } else {
             selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
         }
@@ -289,7 +289,7 @@ async function devServer() {
 /* -------------------------------------------------------
  * BUILD
  * ----------------------------------------------------- */
-function buildProd() {
+async function buildProd() {
     console.log(cyan("Titan: Building production output..."));
 
     const root = process.cwd();
@@ -298,11 +298,34 @@ function buildProd() {
     const actionsOut = path.join(serverDir, "actions");
 
     // BASIC CHECKS
-    if (!fs.existsSync(appJs)) {
-        console.log(red("ERROR: app/app.js not found."));
+    if (!fs.existsSync(appJs) && !fs.existsSync(path.join(root, "app", "app.ts"))) {
+        console.log(red("ERROR: app/app.js or app/app.ts not found."));
         process.exit(1);
     }
 
+    // COMPILE TYPESCRIPT IF NEEDED
+    if (fs.existsSync(path.join(root, "tsconfig.json"))) {
+        console.log(cyan("→ Compiling TypeScript..."));
+        try {
+            // We use esbuild for speed and consistency with dev mode
+            const { buildSync } = await import("esbuild");
+            buildSync({
+                entryPoints: [path.join(root, "app", "app.ts")],
+                outfile: appJs,
+                bundle: true,
+                platform: "node",
+                format: "esm",
+                external: ["fs", "path", "esbuild", "chokidar", "typescript"],
+                packages: "external",
+            });
+            console.log(green("✔ TypeScript compiled"));
+        } catch (e) {
+            console.log(red("ERROR: Failed to compile TypeScript."));
+            console.error(e);
+            process.exit(1);
+        }
+    }
+
     // ----------------------------------------------------
     // 1) BUILD METADATA + BUNDLE ACTIONS (ONE TIME ONLY)
     // ----------------------------------------------------
@@ -330,23 +353,42 @@ function buildProd() {
     // 2) BUILD RUST BINARY
     // ----------------------------------------------------
     console.log(cyan("→ Building Rust release binary..."));
-    execSync("cargo build --release", {
-        cwd: serverDir,
-        stdio: "inherit"
-    });
 
-    console.log(green("✔ Titan production build complete!"));
+    // Only build rust if it's a rust project (check Cargo.toml)
+    if (fs.existsSync(path.join(serverDir, "Cargo.toml"))) {
+        execSync("cargo build --release", {
+            cwd: serverDir,
+            stdio: "inherit"
+        });
+        console.log(green("✔ Titan production build complete!"));
+    } else {
+        console.log(green("✔ Titan production build complete (pure JS/TS)!"));
+    }
 }
 
 /* -------------------------------------------------------
  * START
  * ----------------------------------------------------- */
-function startProd() {
+async function startProd() {
     const isWin = process.platform === "win32";
     const bin = isWin ? "titan-server.exe" : "titan-server";
+    const root = process.cwd();
+
+    const exe = path.join(root, "server", "target", "release", bin);
+
+    if (fs.existsSync(exe)) {
+        execSync(`"${exe}"`, { stdio: "inherit" });
+    } else {
+        // Fallback to pure node start if no rust binary
+        const appJs = path.join(root, "app", "app.js");
+        // Actually, typically we run the bundled/compiled app if we don't have rust server?
+        // But wait, the pure TS template runs `node .titan/app.js` in Docker.
+        // But locally `titan start` relies on `app/app.js` being compiled?
+        // In `buildProd` above we compiled to `app/app.js`.
+        // Let's check for `.titan/app.js` which is dev artifact? No, use the prod build artifact.
+        execSync(`node "${appJs}"`, { stdio: "inherit" });
+    }
 
-    const exe = path.join(process.cwd(), "server", "target", "release", bin);
-    execSync(`"${exe}"`, { stdio: "inherit" });
 }
 
 /* -------------------------------------------------------
@@ -586,8 +628,8 @@ if (cmd === "create" && args[1] === "ext") {
             break;
         }
         case "dev": devServer(); break;
-        case "build": buildProd(); break;
-        case "start": startProd(); break;
+        case "build": await buildProd(); break;
+        case "start": await startProd(); break;
         case "update": updateTitan(); break;
         case "--version":
         case "-v":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.9.0",
+  "version": "26.9.1",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",
@@ -13,7 +13,6 @@
   "files": [
     "index.js",
     "templates/",
-    "titan",
     "titanpl-sdk",
     "README.md"
   ],

package/templates/{rust → rust-js}/package.json

@@ -4,7 +4,7 @@
   "description": "A Titan Planet server",
   "type": "module",
   "titan": {
-    "template": "rust"
+    "template": "rust-js"
   },
   "dependencies": {
     "chokidar": "^5.0.0",

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

@@ -1,5 +1,11 @@
-export const hello = (req) => {
-   return {
-        message: `Hello from Titan ${req.body.name}`,
-    };
+interface HelloResponse {
+    message: string;
 }
+
+import { defineAction } from "../../titan/titan";
+
+export const hello = defineAction((req): HelloResponse => {
+    return {
+        message: `Hello from Titan ${req.body.name || "World"}`,
+    };
+});

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

@@ -1,4 +1,4 @@
-import t from "../titan/titan.js";
+import t from "../titan/titan";
 
 
 

package/templates/rust-ts/titan/bundle.js

@@ -2,19 +2,19 @@ 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");
-const rustOutDir = path.join(root, "server", "src", "actions_rust");
-
 export async function bundle() {
+  const root = process.cwd();
+  const actionsDir = path.join(root, "app", "actions");
+  const outDir = path.join(root, "server", "actions");
+  const rustOutDir = path.join(root, "server", "src", "actions_rust");
+
   const start = Date.now();
-  await bundleJs();
-  await bundleRust();
+  await bundleJs(actionsDir, outDir);
+  await bundleRust(rustOutDir, actionsDir);
   // console.log(`[Titan] Bundle finished in ${((Date.now() - start) / 1000).toFixed(2)}s`);
 }
 
-async function bundleJs() {
+async function bundleJs(actionsDir, outDir) {
   // console.log("[Titan] Bundling JS actions...");
 
   fs.mkdirSync(outDir, { recursive: true });
@@ -77,9 +77,15 @@ async function bundleJs() {
   // console.log("[Titan] JS Bundling finished.");
 }
 
-export async function bundleRust() {
+export async function bundleRust(rustOutDir, actionsDir) {
   // console.log("[Titan] Bundling Rust actions...");
 
+  // Fallback if called directly (though typically called via bundle)
+  const root = process.cwd();
+  if (!actionsDir) actionsDir = path.join(root, "app", "actions");
+  if (!rustOutDir) rustOutDir = path.join(root, "server", "src", "actions_rust");
+
+
   if (!fs.existsSync(rustOutDir)) {
     fs.mkdirSync(rustOutDir, { recursive: true });
   }

package/templates/rust-ts/titan/dev.js

@@ -231,11 +231,11 @@ async function rebuild() {
                 bundle: true,
                 platform: "node",
                 format: "esm",
-                packages: "external",
+                external: ["fs", "path", "esbuild", "chokidar", "typescript"],
                 logLevel: "silent"
             });
 
-            execSync(`node "${compiledApp}"`, { stdio: "ignore" });
+            execSync(`node "${compiledApp}"`, { stdio: "inherit" });
         } else {
             execSync("node app/app.js", { stdio: "ignore" });
         }

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

@@ -0,0 +1,117 @@
+
+// -- 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>;
+}
+
+// The default export from titan.js is the Builder
+declare const builder: TitanBuilder;
+export default builder;
+
+/**
+ * Define a Titan Action with type inference.
+ */
+export declare function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+
+// -- Global Definitions (Runtime Environment) --
+
+declare global {
+    /**
+     * 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[];
+    }
+
+    /**
+     * Global defineAction (available without import in runtime, though imports are preferred in TS)
+     */
+    function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+    /**
+     * Global Request Object
+     * Available automatically in actions.
+     */
+    var req: TitanRequest;
+
+    /**
+     * Titan Runtime Utilities
+     * (Available globally in the runtime, e.g. inside actions)
+     */
+    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: any;
+    };
+}

package/templates/rust-ts/titan/titan.js

@@ -1,6 +1,8 @@
+import { bundle } from "./bundle.js";
 import fs from "fs";
 import path from "path";
-import { bundle } from "./bundle.js";
+
+export const defineAction = (handler) => handler;
 
 const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
 const green = (t) => `\x1b[32m${t}\x1b[0m`;
@@ -10,34 +12,33 @@ 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;
-      }
-    }
-  };
+    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;
+            }
+        }
+    };
 }
 
 /**
@@ -50,73 +51,72 @@ function addRoute(method, route) {
  * 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);
+    /**
+     * 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;