titanpl 6.0.0 → 7.0.0

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

@@ -1,284 +0,0 @@
-//! 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

@@ -1,33 +0,0 @@
-//! 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

@@ -1,259 +0,0 @@
-/**
- * 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("titanpl/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__');
-    }
-  }
-}