titanpl 1.0.0

package/titanpl-sdk/templates/server/src/runtime.rs

@@ -0,0 +1,284 @@
+//! Worker Pool Management (Performance Optimized)
+//!
+//! Features:
+//! 1. Work-stealing fallback strategy.
+//! 2. Bounded channel capacity for pipeline handling.
+//! 3. Batch-ready architecture for HTTP pipelining.
+//! 4. Zero-copy / deferred cloning where possible.
+
+use bytes::Bytes;
+use crossbeam::channel::{bounded, Sender, TrySendError};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::thread;
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
+use smallvec::SmallVec;
+
+use crate::extensions::{self, AsyncOpRequest, TitanRuntime, WorkerAsyncResult};
+
+pub struct RuntimeManager {
+    request_txs: Vec<Sender<WorkerCommand>>,
+    round_robin_counter: AtomicUsize,
+    num_workers: usize,
+    _workers: Vec<thread::JoinHandle<()>>,
+}
+
+pub enum WorkerCommand {
+    Request(RequestTask),
+    Resume {
+        drift_id: u32,
+        result: WorkerAsyncResult,
+    },
+}
+
+#[allow(dead_code)]
+pub struct RequestTask {
+    pub action_name: String,
+    pub body: Option<Bytes>,
+    pub method: String,
+    pub path: String,
+    pub headers: SmallVec<[(String, String); 8]>,
+    pub params: SmallVec<[(String, String); 4]>,
+    pub query: SmallVec<[(String, String); 4]>,
+    pub response_tx: oneshot::Sender<WorkerResult>,
+}
+
+pub struct WorkerResult {
+    pub json: serde_json::Value,
+    pub timings: Vec<(String, f64)>,
+}
+
+impl RuntimeManager {
+    pub fn new(
+        project_root: std::path::PathBuf,
+        num_threads: usize,
+        stack_size: usize,
+    ) -> Self {
+        let (async_tx, mut async_rx) = mpsc::channel::<AsyncOpRequest>(2048);
+        let tokio_handle = tokio::runtime::Handle::current();
+
+        // Spawn Tokio Async Handler (for drift operations)
+        tokio_handle.spawn(async move {
+            while let Some(req) = async_rx.recv().await {
+                let drift_id = req.drift_id;
+                let respond_tx = req.respond_tx;
+                tokio::spawn(async move {
+                    let start = std::time::Instant::now();
+                    let result = extensions::builtin::run_async_operation(req.op).await;
+                    let duration_ms = start.elapsed().as_secs_f64() * 1000.0;
+                    let _ = respond_tx.send(WorkerAsyncResult {
+                        drift_id,
+                        result,
+                        duration_ms,
+                    });
+                });
+            }
+        });
+
+        // Create worker channels
+        let channel_capacity = 256;
+        let mut workers = Vec::with_capacity(num_threads);
+
+        let mut channels: Vec<(Sender<WorkerCommand>, crossbeam::channel::Receiver<WorkerCommand>)> =
+            Vec::with_capacity(num_threads);
+
+        for _ in 0..num_threads {
+            let (tx, rx) = bounded(channel_capacity);
+            channels.push((tx, rx));
+        }
+
+        let mut final_txs: Vec<Sender<WorkerCommand>> = Vec::with_capacity(num_threads);
+        for (tx, _) in &channels {
+            final_txs.push(tx.clone());
+        }
+
+        // Spawn Worker Threads
+        for (i, (tx, rx)) in channels.into_iter().enumerate() {
+            let my_tx = tx.clone();
+            let root = project_root.clone();
+            let handle = tokio_handle.clone();
+            let async_tx = async_tx.clone();
+
+            let handle = thread::Builder::new()
+                .name(format!("titan-worker-{}", i))
+                .stack_size(stack_size)
+                .spawn(move || {
+                    let mut rt = extensions::init_runtime_worker(
+                        i,
+                        root,
+                        my_tx,
+                        handle,
+                        async_tx,
+                        stack_size,
+                    );
+                    rt.bind_to_isolate();
+
+                    loop {
+                        match rx.recv() {
+                            Ok(cmd) => match cmd {
+                                WorkerCommand::Request(task) => {
+                                    handle_new_request(task, &mut rt);
+                                }
+                                WorkerCommand::Resume { drift_id, result } => {
+                                    handle_resume(drift_id, result, &mut rt);
+                                }
+                            },
+                            Err(_) => break,
+                        }
+                    }
+                })
+                .expect("Failed to spawn worker");
+
+            workers.push(handle);
+        }
+
+        Self {
+            request_txs: final_txs,
+            round_robin_counter: AtomicUsize::new(0),
+            num_workers: num_threads,
+            _workers: workers,
+        }
+    }
+
+    /// Execute an action on a worker. Uses round-robin with work-stealing fallback.
+    pub async fn execute(
+        &self,
+        action: String,
+        method: String,
+        path: String,
+        body: Option<Bytes>,
+        headers: SmallVec<[(String, String); 8]>,
+        params: SmallVec<[(String, String); 4]>,
+        query: SmallVec<[(String, String); 4]>,
+    ) -> Result<(serde_json::Value, Vec<(String, f64)>), String> {
+        let (tx, rx) = oneshot::channel();
+        let task = RequestTask {
+            action_name: action,
+            body,
+            method,
+            path,
+            headers,
+            params,
+            query,
+            response_tx: tx,
+        };
+
+        // Work-Stealing Distribution
+        let start_idx = self.round_robin_counter.fetch_add(1, Ordering::Relaxed) % self.num_workers;
+        let mut cmd = WorkerCommand::Request(task);
+
+        for attempt in 0..self.num_workers {
+            let idx = (start_idx + attempt) % self.num_workers;
+            match self.request_txs[idx].try_send(cmd) {
+                Ok(()) => {
+                    return match rx.await {
+                        Ok(res) => Ok((res.json, res.timings)),
+                        Err(_) => Err("Worker channel closed".to_string()),
+                    };
+                }
+                Err(TrySendError::Full(returned)) => {
+                    cmd = returned;
+                }
+                Err(TrySendError::Disconnected(_)) => {
+                    return Err("Worker disconnected".to_string());
+                }
+            }
+        }
+
+        // All workers full — blocking send to the original target as last resort
+        self.request_txs[start_idx]
+            .send(cmd)
+            .map_err(|e| e.to_string())?;
+
+        match rx.await {
+            Ok(res) => Ok((res.json, res.timings)),
+            Err(_) => Err("Worker channel closed".to_string()),
+        }
+    }
+}
+
+/// Handle a new incoming request.
+///
+/// OPTIMIZATION: Deferred cloning.
+/// Only stores data if drift (async suspend) happens.
+fn handle_new_request(task: RequestTask, rt: &mut TitanRuntime) {
+    rt.request_counter += 1;
+    let request_id = rt.request_counter;
+
+    // Move response_tx into pending (partial move of task — other fields remain accessible)
+    rt.pending_requests.insert(request_id, task.response_tx);
+
+    let drift_count = rt.drift_counter;
+    rt.request_start_counters.insert(request_id, drift_count);
+
+    // Execute action — pass references, body is O(1) Bytes clone
+    extensions::execute_action_optimized(
+        rt,
+        request_id,
+        &task.action_name,
+        task.body.clone(), // Bytes::clone() is O(1) refcount bump
+        &task.method,
+        &task.path,
+        &task.headers,
+        &task.params,
+        &task.query,
+    );
+
+    // Deferred cloning decision
+    if !rt.pending_requests.contains_key(&request_id) {
+        // Completed synchronously — no data needed, minimal cleanup
+        rt.request_start_counters.remove(&request_id);
+    } else {
+        // Suspended via drift — MOVE (not clone) data for resume replay.
+        rt.active_requests.insert(
+            request_id,
+            extensions::RequestData {
+                action_name: task.action_name,
+                body: task.body,
+                method: task.method,
+                path: task.path,
+                headers: task.headers.into_vec(),
+                params: task.params.into_vec(),
+                query: task.query.into_vec(),
+            },
+        );
+    }
+}
+
+fn handle_resume(drift_id: u32, result: WorkerAsyncResult, rt: &mut TitanRuntime) {
+    let req_id = rt.drift_to_request.get(&drift_id).copied().unwrap_or(0);
+
+    let timing_type = if result.result.get("error").is_some() {
+        "drift_error"
+    } else {
+        "drift"
+    };
+    rt.request_timings
+        .entry(req_id)
+        .or_default()
+        .push((timing_type.to_string(), result.duration_ms));
+
+    rt.completed_drifts.insert(drift_id, result.result);
+
+    if let Some(req_data) = rt.active_requests.get(&req_id).cloned() {
+        let start_counter = rt.request_start_counters.get(&req_id).copied().unwrap_or(0);
+        rt.drift_counter = start_counter;
+
+        extensions::execute_action_optimized(
+            rt,
+            req_id,
+            &req_data.action_name,
+            req_data.body,
+            &req_data.method,
+            &req_data.path,
+            &req_data.headers,
+            &req_data.params,
+            &req_data.query,
+        );
+    }
+
+    if req_id != 0 && !rt.pending_requests.contains_key(&req_id) {
+        rt.active_requests.remove(&req_id);
+        rt.request_start_counters.remove(&req_id);
+    }
+}

package/titanpl-sdk/templates/server/src/utils.rs

@@ -0,0 +1,33 @@
+//! Terminal styling and utility functions.
+
+pub fn blue(s: &str) -> String {
+    format!("\x1b[38;5;39m{}\x1b[0m", s)
+}
+pub fn white(s: &str) -> String {
+    format!("\x1b[39m{}\x1b[0m", s)
+}
+pub fn yellow(s: &str) -> String {
+    format!("\x1b[33m{}\x1b[0m", s)
+}
+pub fn green(s: &str) -> String {
+    format!("\x1b[32m{}\x1b[0m", s)
+}
+pub fn gray(s: &str) -> String {
+    format!("\x1b[90m{}\x1b[0m", s)
+}
+pub fn red(s: &str) -> String {
+    format!("\x1b[31m{}\x1b[0m", s)
+}
+
+pub fn parse_expires_in(value: &str) -> Option<u64> {
+    let (num, unit) = value.split_at(value.len() - 1);
+    let n: u64 = num.parse().ok()?;
+
+    match unit {
+        "s" => Some(n),
+        "m" => Some(n * 60),
+        "h" => Some(n * 60 * 60),
+        "d" => Some(n * 60 * 60 * 24),
+        _ => None,
+    }
+}

package/titanpl-sdk/templates/titan/bundle.js

@@ -0,0 +1,259 @@
+/**
+ * Bundle.js
+ * Handles esbuild bundling with comprehensive error reporting
+ * RULE: This file handles ALL esbuild errors and prints error boxes directly
+ */
+
+import esbuild from 'esbuild';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { renderErrorBox, parseEsbuildError } from './error-box.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Required for resolving node_modules inside ESM
+const require = createRequire(import.meta.url);
+
+/**
+ * Titan Node Builtin Rewrite Map
+ * Rewrites Node builtins to @titanpl/node shims
+ */
+const NODE_BUILTIN_MAP = {
+  "fs": "@titanpl/node/fs",
+  "node:fs": "@titanpl/node/fs",
+
+  "path": "@titanpl/node/path",
+  "node:path": "@titanpl/node/path",
+
+  "os": "@titanpl/node/os",
+  "node:os": "@titanpl/node/os",
+
+  "crypto": "@titanpl/node/crypto",
+  "node:crypto": "@titanpl/node/crypto",
+
+  "process": "@titanpl/node/process",
+  
+  "util": "@titanpl/node/util",
+  "node:util": "@titanpl/node/util",
+};
+
+/**
+ * Titan Node Compatibility Plugin
+ * Rewrites require/import of Node builtins
+ * Returns absolute paths (required by esbuild)
+ */
+const titanNodeCompatPlugin = {
+  name: "titan-node-compat",
+  setup(build) {
+    build.onResolve({ filter: /.*/ }, args => {
+      if (NODE_BUILTIN_MAP[args.path]) {
+        try {
+          const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
+          return { path: resolved };
+        } catch (e) {
+          throw new Error(
+            `[Titan] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`
+          );
+        }
+      }
+    });
+  }
+};
+
+/**
+ * Get Titan version for error branding
+ */
+function getTitanVersion() {
+  try {
+    const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+  } catch (e) {
+    return "0.1.0";
+  }
+}
+
+/**
+ * Custom error class for bundle errors
+ */
+export class BundleError extends Error {
+  constructor(message, errors = [], warnings = []) {
+    super(message);
+    this.name = 'BundleError';
+    this.errors = errors;
+    this.warnings = warnings;
+    this.isBundleError = true;
+  }
+}
+
+/**
+ * Validate entry file exists
+ */
+async function validateEntryPoint(entryPoint) {
+  const absPath = path.resolve(entryPoint);
+
+  if (!fs.existsSync(absPath)) {
+    throw new BundleError(
+      `Entry point does not exist: ${entryPoint}`,
+      [{ text: `Cannot find file: ${absPath}`, location: { file: entryPoint } }]
+    );
+  }
+
+  try {
+    await fs.promises.access(absPath, fs.constants.R_OK);
+  } catch {
+    throw new BundleError(
+      `Entry point is not readable: ${entryPoint}`,
+      [{ text: `Cannot read file: ${absPath}`, location: { file: entryPoint } }]
+    );
+  }
+}
+
+/**
+ * Bundles a single file
+ */
+export async function bundleFile(options) {
+  const {
+    entryPoint,
+    outfile,
+    format = 'iife',
+    minify = false,
+    sourcemap = false,
+    platform = 'neutral',
+    globalName = '__titan_exports',
+    target = 'es2020',
+    banner = {},
+    footer = {}
+  } = options;
+
+  await validateEntryPoint(entryPoint);
+
+  const outDir = path.dirname(outfile);
+  await fs.promises.mkdir(outDir, { recursive: true });
+
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      outfile,
+      format,
+      globalName,
+      platform,
+      target,
+      banner,
+      footer,
+      minify,
+      sourcemap,
+      logLevel: 'silent',
+      logLimit: 0,
+      write: true,
+      metafile: false,
+      plugins: [titanNodeCompatPlugin],
+    });
+
+    if (result.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${result.errors.length} error(s)`,
+        result.errors,
+        result.warnings || []
+      );
+    }
+
+  } catch (err) {
+    if (err.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${err.errors.length} error(s)`,
+        err.errors,
+        err.warnings || []
+      );
+    }
+
+    throw new BundleError(
+      `Unexpected build error: ${err.message}`,
+      [{ text: err.message, location: { file: entryPoint } }]
+    );
+  }
+}
+
+/**
+ * Main bundler
+ */
+export async function bundle() {
+  const root = process.cwd();
+  const actionsDir = path.join(root, 'app', 'actions');
+  const bundleDir = path.join(root, 'server', 'src', 'actions');
+
+  if (fs.existsSync(bundleDir)) {
+    fs.rmSync(bundleDir, { recursive: true, force: true });
+  }
+  await fs.promises.mkdir(bundleDir, { recursive: true });
+
+  if (!fs.existsSync(actionsDir)) return;
+
+  const files = fs.readdirSync(actionsDir).filter(f =>
+    (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
+  );
+
+  for (const file of files) {
+    const actionName = path.basename(file, path.extname(file));
+    const entryPoint = path.join(actionsDir, file);
+    const outfile = path.join(bundleDir, actionName + ".jsbundle");
+
+    try {
+      await bundleFile({
+        entryPoint,
+        outfile,
+        format: 'iife',
+        globalName: '__titan_exports',
+        platform: 'node',
+        target: 'es2020',
+        banner: { js: "var Titan = t;" },
+        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}"] = globalThis.defineAction(fn);
+})();
+`
+        }
+      });
+
+    } catch (error) {
+
+      console.error();
+
+      const titanVersion = getTitanVersion();
+
+      if (error.isBundleError && error.errors?.length) {
+        for (let i = 0; i < error.errors.length; i++) {
+          const errorInfo = parseEsbuildError(error.errors[i]);
+          if (error.errors.length > 1) {
+            errorInfo.title = `Build Error ${i + 1}/${error.errors.length}`;
+          }
+          errorInfo.titanVersion = titanVersion;
+          console.error(renderErrorBox(errorInfo));
+          console.error();
+        }
+      } else {
+        const errorInfo = {
+          title: 'Build Error',
+          file: entryPoint,
+          message: error.message || 'Unknown error',
+          titanVersion
+        };
+        console.error(renderErrorBox(errorInfo));
+      }
+
+      throw new Error('__TITAN_BUNDLE_FAILED__');
+    }
+  }
+}