titanpl-sdk 3.0.0 → 6.0.0

package/templates/server/src/extensions/mod.rs

@@ -63,6 +63,7 @@ pub enum TitanAsyncOp {
     DbQuery {
         conn: String,
         query: String,
+        params: Vec<String>,
     },
     FsRead {
         path: String,
@@ -470,16 +471,15 @@ pub fn execute_action_optimized(
     let p_val = v8_str(scope, req_path);
     req_obj.set(scope, p_key.into(), p_val.into());
 
-    // rawBody — zero-copy via ArrayBuffer backing store
+    // body — attach raw bytes as ArrayBuffer under "rawBody" key
+    let rb_key = v8::Local::new(scope, &gk_raw_body);
     let body_val: v8::Local<v8::Value> = if let Some(bytes) = req_body {
-        let vec = bytes.to_vec();
-        let store = v8::ArrayBuffer::new_backing_store_from_boxed_slice(vec.into_boxed_slice());
-        let ab = v8::ArrayBuffer::with_backing_store(scope, &store.make_shared());
+        let backing = v8::ArrayBuffer::new_backing_store_from_vec(bytes.to_vec());
+        let ab = v8::ArrayBuffer::with_backing_store(scope, &backing.make_shared());
         ab.into()
     } else {
         v8::null(scope).into()
     };
-    let rb_key = v8::Local::new(scope, &gk_raw_body);
     req_obj.set(scope, rb_key.into(), body_val);
 
     // headers
@@ -577,4 +577,4 @@ pub fn throw(scope: &mut v8::HandleScope, msg: &str) {
     let message = v8_str(scope, msg);
     let exception = v8::Exception::error(scope, message);
     scope.throw_exception(exception);
-}
+}

package/templates/server/src/extensions/titan_core.js

@@ -15,6 +15,32 @@ if (!globalThis.__TITAN_CORE_LOADED__) {
         const wrapped = function (req) {
             const requestId = req.__titan_request_id;
 
+            if (req.rawBody && req.rawBody.byteLength !== undefined) {
+                try {
+                    const decoder = new TextDecoder();
+                    const text = decoder.decode(req.rawBody);
+
+                    const contentType =
+                        (req.headers && req.headers["content-type"]) ||
+                        (req.headers && req.headers["Content-Type"]) ||
+                        "";
+
+                    if (contentType.includes("application/json")) {
+                        req.body = text ? JSON.parse(text) : {};
+                    } else if (contentType.includes("application/x-www-form-urlencoded")) {
+                        req.body = Object.fromEntries(new URLSearchParams(text));
+                    } else {
+                        req.body = text;
+                    }
+                } catch (e) {
+                    req.body = {};
+                }
+            } else {
+                req.body = {};
+            }
+
+            // ===============================
+
             const isSuspend = (err) => {
                 const msg = err && (err.message || String(err));
                 return msg && (msg.includes("__SUSPEND__") || msg.includes("SUSPEND"));
@@ -25,9 +51,7 @@ if (!globalThis.__TITAN_CORE_LOADED__) {
 
                 if (result && typeof result.then === 'function') {
                     result.then(
-                        (data) => {
-                            t._finish_request(requestId, data);
-                        },
+                        (data) => t._finish_request(requestId, data),
                         (err) => {
                             if (isSuspend(err)) return;
                             t._finish_request(requestId, { error: err.message || String(err) });
@@ -54,10 +78,8 @@ if (!globalThis.__TITAN_CORE_LOADED__) {
         }
     };
 
-    // process.env
-    globalThis.process = {
-        env: t.loadEnv ? t.loadEnv() : {}
-    };
+    // Titan Environment API
+    t.env = t.loadEnv ? t.loadEnv() : {};
 
     // Async Proxy Creator
     function createAsyncOp(op) {
@@ -73,8 +95,7 @@ if (!globalThis.__TITAN_CORE_LOADED__) {
                 }
 
                 throw new Error(
-                    `[Titan Error] Accessed '${String(prop)}' without drift(). ` +
-                    `Fix: const res = drift(t.fetch(...));`
+                    `[Titan Error] Accessed '${String(prop)}' without drift(). `
                 );
             }
         });
@@ -185,22 +206,37 @@ if (!globalThis.__TITAN_CORE_LOADED__) {
         t.fetch.__titanWrapped = true;
     }
 
+    // db.connect
     // db.connect
     if (t.db && !t.db.__titanWrapped) {
         const nativeDbConnect = t.db.connect;
 
-        t.db.connect = function (connString) {
-            const conn = nativeDbConnect(connString);
+        t.db.connect = function (connString, options = {}) {
+            const conn = nativeDbConnect(connString, options);
 
             if (!conn.query.__titanWrapped) {
                 const nativeQuery = conn.query;
-                conn.query = (sql) => {
+
+                conn.query = function (sql, params = []) {
+                    if (typeof sql !== "string" || !sql.trim()) {
+                        throw new Error("db.query(): SQL string required");
+                    }
+
+                    if (!Array.isArray(params)) {
+                        throw new Error("db.query(): params must be array");
+                    }
+
                     return createAsyncOp({
                         __titanAsync: true,
                         type: "db_query",
-                        data: { conn: connString, query: sql }
+                        data: {
+                            conn: connString,
+                            query: sql,
+                            params
+                        }
                     });
                 };
+
                 conn.query.__titanWrapped = true;
             }
 

package/templates/server/src/main.rs

@@ -96,7 +96,7 @@ async fn handler(State(state): State<AppState>, req: Request<Body>) -> impl Into
                         "Server-Timing",
                         format!("reply;dur={:.2}", elapsed.as_secs_f64() * 1000.0)
                             .parse()
-                            .unwrap(),
+                            .unwrap_or_else(|_| axum::http::HeaderValue::from_static("")),
                     );
 
                     if log_enabled {
@@ -140,7 +140,7 @@ async fn handler(State(state): State<AppState>, req: Request<Body>) -> impl Into
                         "Server-Timing",
                         format!("fastpath;dur={:.2}", elapsed.as_secs_f64() * 1000.0)
                             .parse()
-                            .unwrap(),
+                            .unwrap_or_else(|_| axum::http::HeaderValue::from_static("")),
                     );
 
                     if log_enabled {
@@ -409,7 +409,7 @@ async fn handler(State(state): State<AppState>, req: Request<Body>) -> impl Into
             .join(", ");
         response
             .headers_mut()
-            .insert("Server-Timing", server_timing.parse().unwrap());
+            .insert("Server-Timing", server_timing.parse().unwrap_or_else(|_| axum::http::HeaderValue::from_static("")));
     }
 
     // Logging