@ezetgalaxy/titan 26.9.0 → 26.9.2

package/templates/ts/titan/runtime.js

@@ -0,0 +1 @@
+export const defineAction = (handler) => handler;

package/templates/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/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 * from "./runtime.js";
 
 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;

package/titanpl-sdk/README.md

@@ -75,11 +75,11 @@ Since the `t` object is injected globally by the Titan engine at runtime, your I
     ```
 
 Now your editor will treat `t` as a first-class citizen:
-```js
-export function myAction(req) {
-  t.log.info("Request received", req.path); // Autocomplete works!
+```ts
+export const myAction = defineAction((req) => {
+  t.log("Request received", req.path); // Autocomplete works!
   return { status: "ok" };
-}
+});
 ```
 
 ---

package/titanpl-sdk/bin/run.js

@@ -53,85 +53,89 @@ function run() {
         }
     }
 
-    // 3. Create a Test Harness (Mini Titan Project)
+    // 3. Setup Test Harness (Mini Titan Project)
     const runDir = path.join(cwd, ".titan_test_run");
-    if (fs.existsSync(runDir)) {
-        try {
-            fs.rmSync(runDir, {
-                recursive: true,
-                force: true,
-                maxRetries: 10,
-                retryDelay: 100
-            });
-        } catch (e) {
-            console.log(yellow(`Warning: Could not fully clean ${runDir}. Proceeding anyway...`));
-        }
-    }
+    const isFirstRun = !fs.existsSync(runDir);
 
-    // Ensure runDir exists (sometimes rmSync + mkdirSync fails on Windows due to locks)
-    if (!fs.existsSync(runDir)) {
+    if (isFirstRun) {
+        console.log(cyan("Initializing test environment..."));
         fs.mkdirSync(runDir, { recursive: true });
-    }
 
-    // Create app structure
-    const appDir = path.join(runDir, "app");
-    fs.mkdirSync(appDir);
-
-    // Create actions folder (required by Titan build)
-    const actionsDir = path.join(appDir, "actions");
-    fs.mkdirSync(actionsDir);
-
-    // Copy titan/ and server/ from templates
-    const templatesDir = path.join(__dirname, "..", "templates");
-
-    const titanSrc = path.join(templatesDir, "titan");
-    const titanDest = path.join(runDir, "titan");
-    if (fs.existsSync(titanSrc)) {
-        console.log(cyan("→ Setting up Titan runtime..."));
-        copyDir(titanSrc, titanDest);
-        // Double check titan.js exists
-        if (!fs.existsSync(path.join(titanDest, "titan.js"))) {
-            console.log(red(`Error: Failed to copy titan.js to ${titanDest}`));
+        // Create app structure
+        const appDir = path.join(runDir, "app");
+        fs.mkdirSync(appDir);
+
+        // Create actions folder (required by Titan build)
+        const actionsDir = path.join(appDir, "actions");
+        fs.mkdirSync(actionsDir);
+
+        // Copy titan/ and server/ from templates
+        const templatesDir = path.join(__dirname, "..", "templates");
+
+        const titanSrc = path.join(templatesDir, "titan");
+        const titanDest = path.join(runDir, "titan");
+        if (fs.existsSync(titanSrc)) {
+            copyDir(titanSrc, titanDest);
+            // Double check titan.js exists
+            if (!fs.existsSync(path.join(titanDest, "titan.js"))) {
+                console.log(red(`Error: Failed to copy titan.js to ${titanDest}`));
+                process.exit(1);
+            }
+        } else {
+            console.log(red(`Error: Titan templates not found at ${titanSrc}`));
             process.exit(1);
         }
-    } else {
-        console.log(red(`Error: Titan templates not found at ${titanSrc}`));
-        process.exit(1);
-    }
 
-    const serverSrc = path.join(templatesDir, "server");
-    const serverDest = path.join(runDir, "server");
-    if (fs.existsSync(serverSrc)) {
-        console.log(cyan("→ Setting up Titan server..."));
-        copyDir(serverSrc, serverDest);
+        const serverSrc = path.join(templatesDir, "server");
+        const serverDest = path.join(runDir, "server");
+        if (fs.existsSync(serverSrc)) {
+            copyDir(serverSrc, serverDest);
+        } else {
+            console.log(red(`Error: Server templates not found at ${serverSrc}`));
+            process.exit(1);
+        }
+
+        // Create package.json for the test harness
+        const pkgJson = {
+            "type": "module"
+        };
+        fs.writeFileSync(path.join(runDir, "package.json"), JSON.stringify(pkgJson, null, 2));
+
+        // Create 'node_modules'
+        fs.mkdirSync(path.join(runDir, "node_modules"));
     } else {
-        console.log(red(`Error: Server templates not found at ${serverSrc}`));
-        process.exit(1);
+        console.log(cyan("Using existing test environment..."));
     }
 
-    // Create package.json for the test harness
-    const pkgJson = {
-        "type": "module"
-    };
-    fs.writeFileSync(path.join(runDir, "package.json"), JSON.stringify(pkgJson, null, 2));
-
-    // Create 'node_modules' to link the extension
+    // Always Ensure Extension Link is Fresh
     const nmDir = path.join(runDir, "node_modules");
-    fs.mkdirSync(nmDir);
+    if (!fs.existsSync(nmDir)) fs.mkdirSync(nmDir, { recursive: true });
 
-    // Link current extension to node_modules/NAME
-    // Use junction for Windows compat without admin rights
     const extDest = path.join(nmDir, name);
+
+    // Remove old link/folder if exists to ensure freshness
+    if (fs.existsSync(extDest)) {
+        try {
+            fs.rmSync(extDest, { recursive: true, force: true });
+        } catch (e) { }
+    }
+
+    // Link current extension to node_modules/NAME
     try {
+        // Use junction for Windows compat without admin rights
         fs.symlinkSync(cwd, extDest, "junction");
     } catch (e) {
         // Fallback to copy if link fails
-        console.log(yellow("Linking failed, copying extension files..."));
+        // console.log(yellow("Linking failed, copying extension files..."));
         copyDir(cwd, extDest);
     }
 
-    // Create a test action in app/actions/test.js
-    const testAction = `export const test = (req) => {
+    // Create default test files ONLY if they don't exist
+    const actionsDir = path.join(runDir, "app", "actions");
+    const testActionPath = path.join(actionsDir, "test.js");
+
+    if (!fs.existsSync(testActionPath)) {
+        const testAction = `export const test = (req) => {
     const ext = t["${name}"];
     
     const results = {
@@ -160,12 +164,12 @@ function run() {
     return results;
 };
 `;
+        fs.writeFileSync(testActionPath, testAction);
+    }
 
-    fs.writeFileSync(path.join(actionsDir, "test.js"), testAction);
-
-    // Create a simple test script in app/app.js
-    // This script will be executed by Titan
-    const testScript = `import t from "../titan/titan.js";
+    const appJsPath = path.join(runDir, "app", "app.js");
+    if (!fs.existsSync(appJsPath)) {
+        const testScript = `import t from "../titan/titan.js";
 import "${name}";
 
 // Extension test harness for: ${name}
@@ -217,37 +221,30 @@ t.get("/").reply("🚀 Extension Test Harness for ${name}\\n\\nVisit /test to se
 
 await t.start(3000, "Titan Extension Test Running!");
 `;
-
-    fs.writeFileSync(path.join(appDir, "app.js"), testScript);
+        fs.writeFileSync(appJsPath, testScript);
+    }
 
     // Build the app (bundle actions)
     console.log(cyan("Building test app..."));
     try {
-        // Ensure we are in runDir and the file exists
-        const appJsPath = path.join(runDir, "app", "app.js");
-        if (!fs.existsSync(appJsPath)) {
-            throw new Error(`app/app.js missing at ${appJsPath}`);
-        }
-
         execSync("node app/app.js --build", {
             cwd: runDir,
             stdio: "inherit",
             env: { ...process.env, NODE_OPTIONS: "--no-warnings" }
         });
     } catch (e) {
-        console.log(red("Failed to build test app. This is expected if your extension has errors."));
-        // Don't exit here, attempt to continue to show runtime errors if possible
+        console.log(red("Failed to build test app. checking for runtime errors..."));
     }
 
-    // 4. Run Titan Server using cargo run (like dev mode)
-    console.log(green("\x1b[1m\n>>> STARTING EXTENSION TEST >>>\n\x1b[0m"));
+    // 4. Run Titan Server using cargo run
+    console.log(green("\\x1b[1m\\n>>> STARTING EXTENSION TEST >>>\\n\\x1b[0m"));
 
     const serverDir = path.join(runDir, "server");
 
     try {
         execSync("cargo run", { cwd: serverDir, stdio: "inherit" });
     } catch (e) {
-        console.log(red("Runtime exited."));
+        // console.log(red("Runtime exited."));
     }
 }
 

package/titanpl-sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "titanpl-sdk",
-    "version": "0.1.6",
+    "version": "0.1.7",
     "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
     "main": "index.js",
     "type": "module",

package/templates/rust/Dockerfile

@@ -1,66 +0,0 @@
-# ================================================================
-# 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/_dockerignore

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

package/templates/rust/_gitignore

@@ -1,38 +0,0 @@
-# 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