@ezetgalaxy/titan 25.15.5 → 25.15.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "25.15.5",
+  "version": "25.15.6",
   "description": "JavaScript backend framework that compiles your JS into a Rust + Axum server.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/titan/bundle.js

@@ -0,0 +1,62 @@
+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");
+
+export async function bundle() {
+  console.log("[Titan] Bundling actions...");
+
+  fs.mkdirSync(outDir, { recursive: true });
+
+  // Clean old bundles
+  for (const file of fs.readdirSync(outDir)) {
+    fs.unlinkSync(path.join(outDir, file));
+  }
+
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".js"));
+
+  for (const file of files) {
+    const actionName = path.basename(file, ".js");
+
+    const entry = path.join(actionsDir, file);
+
+    // Rust runtime expects `.jsbundle` extension — consistent with previous design
+    const outfile = path.join(outDir, file.replace(".js", ".jsbundle"));
+
+    console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+
+    await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      format: "iife",
+      globalName: "__titan_exports",
+      platform: "neutral",
+      target: "es2020",
+
+      footer: {
+        js: `
+    (function () {
+      const fn =
+        __titan_exports["${actionName}"] ||
+        __titan_exports.default;
+    
+      if (typeof fn !== "function") {
+        throw new Error("[Titan] Action '${actionName}' not found or not a function");
+      }
+    
+      globalThis["${actionName}"] = fn;
+    })();
+    `
+      }
+    });
+
+
+
+  }
+
+  console.log("[Titan] Bundling finished.");
+}

package/templates/titan/dev.js

@@ -0,0 +1,67 @@
+import chokidar from "chokidar";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { bundle } from "./bundle.js";
+
+// Required for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let serverProcess = null;
+
+function startRustServer() {
+    if (serverProcess) {
+        serverProcess.kill();
+    }
+
+    const serverPath = path.join(process.cwd(), "server");
+
+    serverProcess = spawn("cargo", ["run"], {
+        cwd: serverPath,
+        stdio: "inherit",
+        shell: true
+    });
+
+    serverProcess.on("close", (code) => {
+        console.log(`[Titan] Rust server exited: ${code}`);
+    });
+}
+
+async function rebuild() {
+    console.log("[Titan] Regenerating routes.json & action_map.json...");
+    execSync("node app/app.js", { stdio: "inherit" });
+
+    console.log("[Titan] Bundling JS actions...");
+    await bundle();
+}
+
+async function startDev() {
+    console.log("[Titan] Dev mode starting...");
+
+    // FIRST BUILD
+    await rebuild();
+    startRustServer();
+
+    const watcher = chokidar.watch("app", {
+        ignoreInitial: true
+    });
+
+    let timer = null;
+
+    watcher.on("all", async (event, file) => {
+        if (timer) clearTimeout(timer);
+
+        timer = setTimeout(async () => {
+            console.log(`[Titan] Change detected: ${file}`);
+
+            await rebuild();
+
+            console.log("[Titan] Restarting Rust server...");
+            startRustServer();
+
+        }, 200);
+    });
+}
+
+startDev();

package/templates/titan/titan.js

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+import { bundle } from "./bundle.js";
+
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+
+const routes = {};
+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 t = {
+  get(route) {
+    return addRoute("GET", route);
+  },
+
+  post(route) {
+    return addRoute("POST", route);
+  },
+
+  async start(port = 3000, msg = "") {
+    console.log(cyan("[Titan] Bundling actions..."));
+    await bundle();
+
+    const base = path.join(process.cwd(), "server");
+    fs.mkdirSync(base, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(base, "routes.json"),
+      JSON.stringify(
+        {
+          __config: { port },
+          routes,
+          __dynamic_routes: Object.values(dynamicRoutes).flat()
+        },
+        null,
+        2
+      )
+    );
+
+    fs.writeFileSync(
+      path.join(base, "action_map.json"),
+      JSON.stringify(actionMap, null, 2)
+    );
+
+    console.log(green(`Titan: routes.json + action_map.json written -> ${base}`));
+    if (msg) console.log(cyan(msg));
+  }
+};
+
+export default t;