@ezetgalaxy/titan 26.8.3 → 26.9.1

package/README.md

@@ -13,6 +13,7 @@
 💙 **Enjoy development mode `titan dev`**
 💟 **Titan Planet docs:** https://titan-docs-ez.vercel.app/docs
 🚀 **CLI: `titan` is now the canonical command. `tit` remains supported as an alias.**
+🛡️ **Strict Mode:** Titan now enforces zero type errors before running.
 
 ---
 
@@ -21,15 +22,15 @@
 [![npm version](https://img.shields.io/npm/v/@ezetgalaxy/titan.svg?style=flat-square)](https://www.npmjs.com/package/@ezetgalaxy/titan)
 
 
-**JavaScript Simplicity. Native Rust Power. Zero Configuration.**
+**TypeScript Precision. JavaScript Simplicity. Native Rust Power. Zero Configuration.**
 
-Titan Planet is a **JavaScript-first Backend Framework** that compiles your application into a single, high-performance native binary. It embeds a V8 JavaScript runtime directly into a specialized Rust + Axum server.
+Titan Planet is a **JavaScript/TypeScript-first Backend Framework** that compiles your application into a single, high-performance native binary. It embeds a V8 JavaScript runtime directly into a specialized Rust + Axum server.
 
-**Start with pure JavaScript.**
+**Start with pure TypeScript/JavaScript.**
 **Need raw power? Add Rust actions seamlessly.**
 Titan handles the compilation, bundling, and routing automatically for both.
 
-Titan = **JavaScript productivity × Rust performance × Zero DevOps**
+Titan = **TS/JS productivity × Rust performance × Zero DevOps**
 
 ---
 
@@ -38,8 +39,8 @@ Titan = **JavaScript productivity × Rust performance × Zero DevOps**
 | Feature                              | Titan | Express/Nest | FastAPI | Bun       |
 | ------------------------------------ | ----- | ------------ | ------- | --------- |
 | Native binary output                 | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Hybrid Rust + JS Actions             | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Pure JavaScript developer experience | ✅ Yes | ✅ Yes        | ❌ No    | ❌ Partial |
+| Hybrid Rust + JS/TS Actions          | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Strict TypeScript Enforcement        | ✅ Yes | ❌ Setup Req. | ❌ No    | ❌ Partial |
 | Zero-config Docker deploy            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 | Action-based architecture            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 | Hot reload dev server                | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
@@ -62,7 +63,9 @@ npm install -g @ezetgalaxy/titan
 titan init my-app
 # Follow the interactive prompt to choose:
 # - JavaScript (Standard)
+# - TypeScript (Strict)
 # - Rust + JavaScript (Beta)
+# - Rust + TypeScript (Beta)
 ```
 
 Inside your project:
@@ -73,10 +76,11 @@ titan dev
 
 You'll see the Titan Dev Server spin up:
 ```
-  Titan Planet   v26.8.0   [ Dev Mode ]
+  Titan Planet   v26.9.1   [ Dev Mode ]
 
-  Type:        Rust + JS Actions
+  Type:        Rust + TS Actions
   Hot Reload:  Enabled
+  Strict Mode: Active 🛡️
 
   • Preparing runtime... Done
   • A new orbit is ready for your app in 0.9s
@@ -87,18 +91,47 @@ You'll see the Titan Dev Server spin up:
 
 # ⚡ Hybrid Action System
 
-Titan is unique because it allows you to write endpoints in **both** JavaScript and Rust within the same project.
+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 { defineAction } from "../../titan/titan";
+
+interface HelloResponse {
+    message: string;
+    user_name: string;
+}
+
+// "defineAction" provides automatic type inference for "req"
+export const hello = defineAction((req): HelloResponse => {
+    t.log("Handling request with strict types...");
+
+    return { 
+        message: "Hello from TypeScript!",
+        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)
@@ -115,17 +148,43 @@ pub async fn run(req: Request<Body>) -> impl IntoResponse {
 }
 ```
 
-**Titan automatically detects, compiles, and routes both types.**
+**Titan automatically detects, compiles, and routes all types.**
+* `.ts` files are type-checked and compiled with esbuild.
 * `.js` files are bundled with esbuild.
 * `.rs` files are compiled into the native binary.
-* Both share the same `routes.json` configuration.
+* All share the same `routes.json` configuration.
+
+---
+
+# 🛡️ Strict Type Safety & Error Logs
+
+Titan prioritizes code quality by enforcing **Strict TypeScript** logic during development. 
+
+If `titan dev` detects a type error, the server **will not run**. This ensures you never ship or test broken code.
+
+### Sample Error Output
+When a type error occurs, Titan pauses execution and provides a clear, actionable log:
+
+```text
+[Titan] ❌ TypeScript Error:
+app/actions/payment.ts(12,5): error TS2322: Type 'string' is not assignable to type 'number'.
+
+    10 |    const amount: number = req.body.amount;
+    11 |    
+  > 12 |    processPayment( "100" ); // Error here
+       |    ^^^^^^^^^^^^^^^^^^^^^^^
+
+[Titan] 🛑 Server paused due to type errors. Fix them to resume.
+```
+
+Once fixed, the server automatically resumes.
 
 ---
 
 # ✨ Core Capabilities
 
 ### 🔌 Unified Runtime API (`t`)
-Both JS and Rust actions have access to the powerful `t` namespace:
+All actions (JS/TS/Rust) have access to the powerful `t` namespace:
 
 * `t.fetch(url, options)` — High-performance HTTP client
 * `t.log(msg)` — Sandboxed, structured logging
@@ -143,7 +202,7 @@ Extend the runtime with custom Rust engines using **Titan Extensions**.
 
 # 📦 Deployment
 
-Titan compiles your entire app—JS code, Rust code, and server logic—into a **single executable**.
+Titan compiles your entire app—JS/TS code, Rust code, and server logic—into a **single executable**.
 
 * **Tiny Docker Images**: Alpine-based, ~20MB compressed.
 * **Instant Startup**: No node_modules overhead.
@@ -152,7 +211,7 @@ Titan compiles your entire app—JS code, Rust code, and server logic—into a *
 ---
 
 # 🧱 Architecture Note
-Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript.
+Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript/TypeScript.
 * **No Event Loop** for JS (Request/Response model).
 * **No `require`** (Use raw imports or bundled dependencies).
 * **True Isolation** per request.
@@ -161,6 +220,6 @@ Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript
 
 **Titan v26 — Stable**
 * Production-ready Hybrid Runtime
+* 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
@@ -123,37 +123,82 @@ ${yellow("Note: `tit` is supported as a legacy alias.")}
  * INIT
  * ----------------------------------------------------- */
 async function initProject(name, templateName) {
-    if (!name) {
-        console.log(red("Usage: titan init <project> [--template <js|rust>]"));
-        return;
+    let projName = name;
+
+    if (!projName) {
+        const response = await prompts({
+            type: 'text',
+            name: 'value',
+            message: 'Project name:',
+            initial: 'my-titan-app'
+        });
+
+        if (!response.value) {
+            console.log(red("✖ Operation cancelled"));
+            return;
+        }
+        projName = response.value;
     }
 
     let selectedTemplate = templateName;
 
     if (!selectedTemplate) {
-        const response = await prompts({
+        // 1. Language Selection
+        const langRes = await prompts({
             type: 'select',
             name: 'value',
-            message: 'Select a template:',
+            message: 'Select language:',
             choices: [
-                { title: 'JavaScript', description: 'Standard Titan app with JS actions', value: 'js' },
-                { title: `Rust + JavaScript  ${yellow('(Beta)')}`, description: 'High-performance Rust actions + JS flexibility', value: 'rust' }
+                { title: 'JavaScript', value: 'js' },
+                { title: 'TypeScript', value: 'ts' }
             ],
             initial: 0
         });
 
-        if (!response.value) {
+        if (!langRes.value) {
+            console.log(red("✖ Operation cancelled"));
+            return;
+        }
+        const lang = langRes.value;
+
+        // 2. Template Selection
+        const archRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select template:',
+            choices: [
+                {
+                    title: `Standard (${lang.toUpperCase()})`,
+                    description: `Standard Titan app with ${lang.toUpperCase()} actions`,
+                    value: 'standard'
+                },
+                {
+                    title: `Rust + ${lang.toUpperCase()} (Hybrid)`,
+                    description: `High-performance Rust actions + ${lang.toUpperCase()} flexibility`,
+                    value: 'hybrid'
+                }
+            ],
+            initial: 0
+        });
+
+        if (!archRes.value) {
             console.log(red("✖ Operation cancelled"));
             return;
         }
-        selectedTemplate = response.value;
+        const arch = archRes.value;
+
+        if (lang === 'js') {
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust-js';
+        } else {
+            selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
+        }
     }
 
-    const target = path.join(process.cwd(), name);
+    const target = path.join(process.cwd(), projName);
     const templateDir = path.join(__dirname, "templates", selectedTemplate);
 
     if (!fs.existsSync(templateDir)) {
-        console.log(red(`Template '${selectedTemplate}' not found. Available: js, rust`));
+        console.log(red(`Template '${selectedTemplate}' not found.`));
         return;
     }
 
@@ -164,7 +209,7 @@ async function initProject(name, templateName) {
 
     console.log("\n" + bold(cyan("🚀 Initializing Titan Project...")));
     console.log(gray(`   Target:   ${target}`));
-    console.log(gray(`   Template: ${selectedTemplate === 'rust' ? 'Rust + JS (Native Perf)' : 'JavaScript (Standard)'}`));
+    console.log(gray(`   Template: ${selectedTemplate}`));
 
     // ----------------------------------------------------------
     // 1. Copy full template directory
@@ -198,7 +243,7 @@ async function initProject(name, templateName) {
     console.log(cyan("📦 Installing dependencies..."));
 
     try {
-        execSync(`npm install esbuild chokidar --silent`, {
+        execSync(`npm install --silent`, {
             cwd: target,
             stdio: "inherit",
         });
@@ -210,7 +255,7 @@ async function initProject(name, templateName) {
     console.log("\n" + bold(green("🎉 You're all set!")));
     console.log(`
   ${gray("Next steps:")}
-    ${cyan(`cd ${name}`)}
+    ${cyan(`cd ${projName}`)}
     ${cyan("titan dev")}
 `);
 }
@@ -244,7 +289,7 @@ async function devServer() {
 /* -------------------------------------------------------
  * BUILD
  * ----------------------------------------------------- */
-function buildProd() {
+async function buildProd() {
     console.log(cyan("Titan: Building production output..."));
 
     const root = process.cwd();
@@ -253,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)
     // ----------------------------------------------------
@@ -285,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" });
 }
 
 /* -------------------------------------------------------
@@ -335,7 +422,9 @@ function updateTitan() {
     }
 
     if (!fs.existsSync(templateServer)) {
-        console.log(red("CLI is corrupted — server template missing."));
+        console.log(red(`CLI seems corrupted or incomplete.`));
+        console.log(red(`Expected server template at: ${templateServer}`));
+        console.log(yellow(`If you are running from npx, try clearing cache or installing a specific version.`));
         return;
     }
 
@@ -539,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.8.3",
+  "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/extension/README.md

@@ -1,104 +1,104 @@
-# 🪐 Titan Extension: {{name}}
-
-> Elevate Titan Planet with custom JavaScript and high-performance Native Rust logic.
-
-Welcome to your new Titan extension! This template provides everything you need to build, test, and deploy powerful additions to the Titan project.
-
----
-
-## 🛠 Project Structure
-
-- `index.js`: The JavaScript entry point where you define your extension's API on the global `t` object.
-- `titan.json`: Manifest file defining extension metadata and Native module mappings.
-- `native/`: Directory for Rust source code.
-  - `src/lib.rs`: Your Native function implementations.
-  - `Cargo.toml`: Rust package and dependency configuration.
-- `jsconfig.json`: Enables full IntelliSense for the Titan Runtime API.
-
----
-
-## 🚀 Quick Start
-
-### 1. Install Dependencies
-Get full type support in your IDE:
-```bash
-npm install
-```
-
-### 2. Build Native Module (Optional)
-If your extension uses Rust, compile it to a dynamic library:
-```bash
-cd native
-cargo build --release
-cd ..
-```
-
-### 3. Test the Extension
-Use the Titan SDK to run a local test harness:
-```bash
-titan run ext
-```
-*Tip: Visit `http://localhost:3000/test` after starting the runner to see your extension in action!*
-
----
-
-## 💻 Development Guide
-
-### Writing JavaScript
-Extensions interact with the global `t` object. It's best practice to namespace your extension:
-
-```javascript
-t.{{name}} = {
-    myMethod: (val) => {
-        t.log("{{name}}", "Doing something...");
-        return val * 2;
-    }
-};
-```
-
-### Writing Native Rust Functions
-Native functions should be marked with `#[unsafe(no_mangle)]` and use `extern "C"`:
-
-```rust
-#[unsafe(no_mangle)]
-pub extern "C" fn multiply(a: f64, b: f64) -> f64 {
-    a * b
-}
-```
-
-### Mapping Native Functions in `titan.json`
-Expose your Rust functions to JavaScript by adding them to the `native.functions` section:
-
-```json
-"functions": {
-    "add": {
-        "symbol": "add",
-        "parameters": ["f64", "f64"],
-        "result": "f64"
-    }
-}
-```
-
----
-
-## 🧪 Testing with Titan SDK
-
-The `titan run ext` command automates the testing workflow:
-1. It builds your native code.
-2. It sets up a temporary Titan project environment.
-3. It links your extension into `node_modules`.
-4. It starts the Titan Runtime at `http://localhost:3000`.
-
-You can modify the test harness or add custom test cases by exploring the generated `.titan_test_run` directory (it is git-ignored).
-
----
-
-## 📦 Deployment
-To use your extension in a Titan project:
-1. Publish your extension to npm or link it locally.
-2. In your Titan project: `npm install my-extension`.
-3. The Titan Runtime will automatically detect and load your extension if it contains a `titan.json`.
-
----
-
-Happy coding on Titan Planet! 🚀
+# 🪐 Titan Extension: {{name}}
+
+> Elevate Titan Planet with custom JavaScript and high-performance Native Rust logic.
+
+Welcome to your new Titan extension! This template provides everything you need to build, test, and deploy powerful additions to the Titan project.
+
+---
+
+## 🛠 Project Structure
+
+- `index.js`: The JavaScript entry point where you define your extension's API on the global `t` object.
+- `titan.json`: Manifest file defining extension metadata and Native module mappings.
+- `native/`: Directory for Rust source code.
+  - `src/lib.rs`: Your Native function implementations.
+  - `Cargo.toml`: Rust package and dependency configuration.
+- `jsconfig.json`: Enables full IntelliSense for the Titan Runtime API.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+Get full type support in your IDE:
+```bash
+npm install
+```
+
+### 2. Build Native Module (Optional)
+If your extension uses Rust, compile it to a dynamic library:
+```bash
+cd native
+cargo build --release
+cd ..
+```
+
+### 3. Test the Extension
+Use the Titan SDK to run a local test harness:
+```bash
+titan run ext
+```
+*Tip: Visit `http://localhost:3000/test` after starting the runner to see your extension in action!*
+
+---
+
+## 💻 Development Guide
+
+### Writing JavaScript
+Extensions interact with the global `t` object. It's best practice to namespace your extension:
+
+```javascript
+t.{{name}} = {
+    myMethod: (val) => {
+        t.log("{{name}}", "Doing something...");
+        return val * 2;
+    }
+};
+```
+
+### Writing Native Rust Functions
+Native functions should be marked with `#[unsafe(no_mangle)]` and use `extern "C"`:
+
+```rust
+#[unsafe(no_mangle)]
+pub extern "C" fn multiply(a: f64, b: f64) -> f64 {
+    a * b
+}
+```
+
+### Mapping Native Functions in `titan.json`
+Expose your Rust functions to JavaScript by adding them to the `native.functions` section:
+
+```json
+"functions": {
+    "add": {
+        "symbol": "add",
+        "parameters": ["f64", "f64"],
+        "result": "f64"
+    }
+}
+```
+
+---
+
+## 🧪 Testing with Titan SDK
+
+The `titan run ext` command automates the testing workflow:
+1. It builds your native code.
+2. It sets up a temporary Titan project environment.
+3. It links your extension into `node_modules`.
+4. It starts the Titan Runtime at `http://localhost:3000`.
+
+You can modify the test harness or add custom test cases by exploring the generated `.titan_test_run` directory (it is git-ignored).
+
+---
+
+## 📦 Deployment
+To use your extension in a Titan project:
+1. Publish your extension to npm or link it locally.
+2. In your Titan project: `npm install my-extension`.
+3. The Titan Runtime will automatically detect and load your extension if it contains a `titan.json`.
+
+---
+
+Happy coding on Titan Planet! 🚀