titanpl-sdk 2.0.0 → 2.0.2

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

@@ -16,15 +16,19 @@ pub struct Registry {
     pub _libs: Vec<Library>, 
     pub modules: Vec<ModuleDef>,
     pub natives: Vec<NativeFnEntry>,
+    pub v8_natives: Vec<usize>,
 }
 
+
 #[derive(Clone)]
 pub struct ModuleDef {
     pub name: String,
     pub js: String,
     pub native_indices: HashMap<String, usize>,
+    pub v8_native_indices: HashMap<String, usize>,
 }
 
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum ParamType {
     String, F64, Bool, Json, Buffer,
@@ -56,9 +60,18 @@ struct TitanConfig {
 #[derive(serde::Deserialize)]
 struct TitanNativeConfig {
     path: String,
+    #[serde(default)]
     functions: HashMap<String, TitanNativeFunc>,
+    #[serde(default)]
+    v8_functions: HashMap<String, TitanV8Func>,
 }
 
+#[derive(serde::Deserialize)]
+struct TitanV8Func {
+    symbol: String,
+}
+
+
 #[derive(serde::Deserialize)]
 struct TitanNativeFunc {
     symbol: String,
@@ -95,6 +108,8 @@ pub fn load_project_extensions(root: PathBuf) {
     let mut modules = Vec::new();
     let mut libs = Vec::new();
     let mut all_natives = Vec::new();
+    let mut all_v8_natives = Vec::new();
+
 
     let mut node_modules = root.join("node_modules");
     if !node_modules.exists() {
@@ -104,8 +119,11 @@ pub fn load_project_extensions(root: PathBuf) {
         }
     }
     
-    if node_modules.exists() {
-        for entry in WalkDir::new(&node_modules).follow_links(true).min_depth(1).max_depth(4) {
+    // Generic scanner helper
+    let scan_dir = |path: PathBuf, modules: &mut Vec<ModuleDef>, libs: &mut Vec<Library>, all_natives: &mut Vec<NativeFnEntry>, all_v8_natives: &mut Vec<usize>| {
+
+        if !path.exists() { return; }
+        for entry in WalkDir::new(&path).follow_links(true).min_depth(1).max_depth(4) {
             let entry = match entry { Ok(e) => e, Err(_) => continue };
             if entry.file_type().is_file() && entry.file_name() == "titan.json" {
                 let dir = entry.path().parent().unwrap();
@@ -115,30 +133,74 @@ pub fn load_project_extensions(root: PathBuf) {
                     Err(_) => continue,
                 };
                 let mut mod_natives_map = HashMap::new();
+                let mut mod_v8_natives_map = HashMap::new();
                 if let Some(native_conf) = config.native {
+
                      let lib_path = dir.join(&native_conf.path);
                      unsafe {
-                         if let Ok(lib) = Library::new(&lib_path) {
-                             for (fn_name, fn_conf) in native_conf.functions {
-                                 let params = fn_conf.parameters.iter().map(|p| parse_type(&p.to_lowercase())).collect();
-                                 let ret = parse_return(&fn_conf.result.to_lowercase());
-                                 if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes()) {
-                                      let idx = all_natives.len();
-                                      all_natives.push(NativeFnEntry { symbol_ptr: *symbol as usize, sig: Signature { params, ret } });
-                                      mod_natives_map.insert(fn_name, idx);
+                         // Try loading library
+                         let lib_load = Library::new(&lib_path);
+                         // If failed, try resolving relative to current dir or LD_LIBRARY_PATH implicit
+                         // But usually absolute path from `dir` works.
+                         match lib_load {
+                            Ok(lib) => {
+                                 for (fn_name, fn_conf) in &native_conf.functions {
+                                     let params = fn_conf.parameters.iter().map(|p| parse_type(&p.to_lowercase())).collect();
+                                     let ret = parse_return(&fn_conf.result.to_lowercase());
+                                     if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes()) {
+                                          let idx = all_natives.len();
+                                          all_natives.push(NativeFnEntry { symbol_ptr: *symbol as usize, sig: Signature { params, ret } });
+                                          mod_natives_map.insert(fn_name.clone(), idx);
+                                     } else {
+                                          println!("{} {} {} -> {}", blue("[Titan]"), red("Symbol not found:"), fn_conf.symbol, config.name);
+                                     }
+                                 }
+                                 
+                                 for (fn_name, fn_conf) in &native_conf.v8_functions {
+                                      if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes()) {
+                                          let idx = all_v8_natives.len();
+                                          all_v8_natives.push(*symbol as usize);
+                                          mod_v8_natives_map.insert(fn_name.clone(), idx);
+                                      } else {
+                                          println!("{} {} {} -> {}", blue("[Titan]"), red("V8 Symbol not found:"), fn_conf.symbol, config.name);
+                                      }
                                  }
-                             }
-                             libs.push(lib);
+
+                                 libs.push(lib);
+                            },
+                            Err(e) => {
+                                println!("{} {} {} -> {:?}", blue("[Titan]"), red("Failed to load native lib:"), config.name, e);
+                            }
                          }
                      }
                 }
                 let js_path = dir.join(&config.main);
-                modules.push(ModuleDef { name: config.name.clone(), js: fs::read_to_string(js_path).unwrap_or_default(), native_indices: mod_natives_map });
+                modules.push(ModuleDef { 
+                    name: config.name.clone(), 
+                    js: fs::read_to_string(js_path).unwrap_or_default(), 
+                    native_indices: mod_natives_map,
+                    v8_native_indices: mod_v8_natives_map
+                });
+
                 println!("{} {} {}", blue("[Titan]"), green("Extension loaded:"), config.name);
             }
         }
+    };
+
+    // Scan node_modules
+    if node_modules.exists() {
+        scan_dir(node_modules, &mut modules, &mut libs, &mut all_natives, &mut all_v8_natives);
     }
-    *REGISTRY.lock().unwrap() = Some(Registry { _libs: libs, modules, natives: all_natives });
+
+
+    // Scan .ext (Production / Docker)
+    let ext_dir = root.join(".ext");
+    if ext_dir.exists() {
+        scan_dir(ext_dir, &mut modules, &mut libs, &mut all_natives, &mut all_v8_natives);
+    }
+    
+    *REGISTRY.lock().unwrap() = Some(Registry { _libs: libs, modules, natives: all_natives, v8_natives: all_v8_natives });
+
 }
 
 pub fn inject_external_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Object>, t_obj: v8::Local<v8::Object>) {
@@ -146,9 +208,10 @@ pub fn inject_external_extensions(scope: &mut v8::HandleScope, global: v8::Local
     let invoke_key = v8_str(scope, "__titan_invoke_native");
     global.set(scope, invoke_key.into(), invoke_fn.into());
 
-    let modules = if let Ok(guard) = REGISTRY.lock() {
-        guard.as_ref().map(|r| r.modules.clone()).unwrap_or_default()
-    } else { vec![] };
+    let (modules, v8_native_ptrs) = if let Ok(guard) = REGISTRY.lock() {
+        (guard.as_ref().map(|r| r.modules.clone()).unwrap_or_default(), guard.as_ref().map(|r| r.v8_natives.clone()).unwrap_or_default())
+    } else { (vec![], vec![]) };
+
 
     for module in modules {
          let mod_obj = v8::Object::new(scope);
@@ -162,6 +225,24 @@ pub fn inject_external_extensions(scope: &mut v8::HandleScope, global: v8::Local
                   }
               }
          }
+
+         for (fn_name, &idx) in &module.v8_native_indices {
+             if let Some(&ptr) = v8_native_ptrs.get(idx) {
+                 if ptr != 0 {
+                     unsafe {
+                         let ext = v8::External::new(scope, ptr as *mut std::ffi::c_void);
+                         let templ = v8::FunctionTemplate::builder(native_invoke_v8_proxy)
+                             .data(ext.into())
+                             .build(scope);
+                         
+                         if let Some(func) = templ.get_function(scope) {
+                             let key = v8_str(scope, fn_name);
+                             mod_obj.set(scope, key.into(), func.into());
+                         }
+                     }
+                 }
+             }
+         }
          let mod_key = v8_str(scope, &module.name);
          t_obj.set(scope, mod_key.into(), mod_obj.into());
          
@@ -249,6 +330,20 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
     }
 }
 
+fn native_invoke_v8_proxy(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, retval: v8::ReturnValue) {
+    let val = args.data();
+    if let Ok(ext) = v8::Local::<v8::External>::try_from(val) {
+         let ptr = ext.value() as *mut std::ffi::c_void;
+         if !ptr.is_null() {
+             unsafe {
+                 type TitanV8Handler = extern "C" fn(&mut v8::HandleScope, v8::FunctionCallbackArguments, v8::ReturnValue);
+                 let handler: TitanV8Handler = std::mem::transmute(ptr);
+                 handler(scope, args, retval);
+             }
+         }
+    }
+}
+
 fn arg_from_v8(scope: &mut v8::HandleScope, val: v8::Local<v8::Value>, ty: &ParamType) -> serde_json::Value {
     match ty {
         ParamType::String => serde_json::Value::String(val.to_rust_string_lossy(scope)),

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

@@ -21,6 +21,7 @@ use v8;
 // ----------------------------------------------------------------------------
 
 pub static SHARE_CONTEXT: OnceLock<ShareContextStore> = OnceLock::new();
+pub static PROJECT_ROOT: OnceLock<PathBuf> = OnceLock::new();
 
 pub struct ShareContextStore {
     pub kv: DashMap<String, serde_json::Value>,
@@ -40,22 +41,91 @@ impl ShareContextStore {
 }
 
 // Re-exports for easier access
-pub use external::load_project_extensions;
+pub fn load_project_extensions(root: PathBuf) {
+    PROJECT_ROOT.get_or_init(|| root.clone());
+    external::load_project_extensions(root);
+}
 
 // ----------------------------------------------------------------------------
 // TITAN RUNTIME
 // ----------------------------------------------------------------------------
 
+pub enum TitanAsyncOp {
+    Fetch {
+        url: String,
+        method: String,
+        body: Option<String>,
+        headers: Vec<(String, String)>,
+    },
+    DbQuery {
+        conn: String,
+        query: String,
+    },
+    FsRead {
+        path: String,
+    },
+    Batch(Vec<TitanAsyncOp>),
+}
+
+pub struct WorkerAsyncResult {
+    pub drift_id: u32,
+    pub result: serde_json::Value,
+    pub duration_ms: f64,
+}
+
+pub struct AsyncOpRequest {
+    pub op: TitanAsyncOp,
+    pub drift_id: u32,
+    pub request_id: u32,
+    pub op_type: String,
+    pub respond_tx: tokio::sync::oneshot::Sender<WorkerAsyncResult>,
+}
+
 pub struct TitanRuntime {
+    pub id: usize,
     pub isolate: v8::OwnedIsolate,
     pub context: v8::Global<v8::Context>,
     pub actions: HashMap<String, v8::Global<v8::Function>>,
     pub worker_tx: crossbeam::channel::Sender<crate::runtime::WorkerCommand>,
+    
+    // Async State
+    pub async_rx: crossbeam::channel::Receiver<WorkerAsyncResult>,
+    pub async_tx: crossbeam::channel::Sender<WorkerAsyncResult>,
+    pub pending_drifts: HashMap<u32, v8::Global<v8::PromiseResolver>>,
+    pub pending_requests: HashMap<u32, tokio::sync::oneshot::Sender<crate::runtime::WorkerResult>>,
+    pub drift_counter: u32,
+    pub request_counter: u32,
+    
+    pub tokio_handle: tokio::runtime::Handle,
+    pub global_async_tx: tokio::sync::mpsc::Sender<AsyncOpRequest>,
+    pub request_timings: HashMap<u32, Vec<(String, f64)>>,
+    pub drift_to_request: HashMap<u32, u32>,
+    pub completed_drifts: HashMap<u32, serde_json::Value>,
+    pub active_requests: HashMap<u32, RequestData>,
+    pub request_start_counters: HashMap<u32, u32>,
+}
+
+#[derive(Clone)]
+pub struct RequestData {
+    pub action_name: String,
+    pub body: Option<Bytes>,
+    pub method: String,
+    pub path: String,
+    pub headers: Vec<(String, String)>,
+    pub params: Vec<(String, String)>,
+    pub query: Vec<(String, String)>,
 }
 
 unsafe impl Send for TitanRuntime {}
 unsafe impl Sync for TitanRuntime {}
 
+impl TitanRuntime {
+    pub fn bind_to_isolate(&mut self) {
+        let ptr = self as *mut TitanRuntime as *mut std::ffi::c_void;
+        self.isolate.set_data(0, ptr);
+    }
+}
+
 static V8_INIT: Once = Once::new();
 
 pub fn init_v8() {
@@ -67,19 +137,19 @@ pub fn init_v8() {
 }
 
 pub fn init_runtime_worker(
+    id: usize,
     root: PathBuf,
     worker_tx: crossbeam::channel::Sender<crate::runtime::WorkerCommand>,
+    tokio_handle: tokio::runtime::Handle,
+    global_async_tx: tokio::sync::mpsc::Sender<AsyncOpRequest>,
+    stack_size: usize,
 ) -> TitanRuntime {
     init_v8();
 
-    // Memory optimization strategy (v8 0.106.0 limitations):
-    // - V8 snapshots reduce memory footprint by sharing compiled code
-    // - Each isolate still has its own heap, but the snapshot reduces base overhead
-    // - For explicit heap limits, use V8 flags: --max-old-space-size=128
-
+    // Memory optimization strategy
     let params = v8::CreateParams::default();
     let mut isolate = v8::Isolate::new(params);
-
+    
     let (global_context, actions_map) = {
         let handle_scope = &mut v8::HandleScope::new(&mut isolate);
         let context = v8::Context::new(handle_scope, v8::ContextOptions::default());
@@ -99,6 +169,7 @@ pub fn init_runtime_worker(
         let action_files = scan_actions(&root);
         for (name, path) in action_files {
             if let Ok(code) = fs::read_to_string(&path) {
+                // Wrap action in an IIFE to capture its exports and register it globally
                 let wrapped_source =
                     format!("(function() {{ {} }})(); globalThis[\"{}\"];", code, name);
                 let source_str = v8_str(scope, &wrapped_source);
@@ -108,19 +179,49 @@ pub fn init_runtime_worker(
                         if val.is_function() {
                             let func = v8::Local::<v8::Function>::try_from(val).unwrap();
                             map.insert(name.clone(), v8::Global::new(try_catch, func));
+                        } else if id == 0 {
+                            println!("[V8] Action '{}' did not evaluate to a function: {:?}", name, val.to_rust_string_lossy(try_catch));
                         }
+                    } else if id == 0 {
+                        let msg = try_catch
+                            .message()
+                            .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
+                            .unwrap_or("Unknown run error".to_string());
+                        println!("[V8] Failed to run action '{}': {}", name, msg);
                     }
+                } else if id == 0 {
+                    let msg = try_catch
+                        .message()
+                        .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
+                        .unwrap_or("Unknown compile error".to_string());
+                    println!("[V8] Failed to compile action '{}': {}", name, msg);
                 }
             }
         }
         (v8::Global::new(scope, context), map)
     };
 
+    let (async_tx, async_rx) = crossbeam::channel::unbounded();
+
     TitanRuntime {
+        id,
         isolate,
         context: global_context,
         actions: actions_map,
         worker_tx,
+        async_rx,
+        async_tx,
+        pending_drifts: HashMap::new(),
+        pending_requests: HashMap::new(),
+        drift_counter: 0,
+        request_counter: 0,
+        tokio_handle,
+        global_async_tx,
+        request_timings: HashMap::new(),
+        drift_to_request: HashMap::new(),
+        completed_drifts: HashMap::new(),
+        active_requests: HashMap::new(),
+        request_start_counters: HashMap::new(),
     }
 }
 
@@ -142,7 +243,7 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     global.set(scope, t_key.into(), t_obj.into());
 }
 
-fn v8_to_json<'s>(
+pub fn v8_to_json<'s>(
     scope: &mut v8::HandleScope<'s>,
     value: v8::Local<v8::Value>,
 ) -> serde_json::Value {
@@ -221,6 +322,7 @@ fn v8_to_json<'s>(
 
 pub fn execute_action_optimized(
     runtime: &mut TitanRuntime,
+    request_id: u32,
     action_name: &str,
     req_body: Option<bytes::Bytes>,
     req_method: &str,
@@ -228,19 +330,22 @@ pub fn execute_action_optimized(
     headers: &[(String, String)],
     params: &[(String, String)],
     query: &[(String, String)],
-) -> serde_json::Value {
-    let TitanRuntime {
-        isolate,
-        context: global_context,
-        actions: actions_map,
-        ..
-    } = runtime;
+) {
+    // Execute action in V8
+    let context_global = runtime.context.clone();
+    let actions_map = runtime.actions.clone(); // Clone the map of globals (cheap)
+    let isolate = &mut runtime.isolate;
+    
     let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Local::new(handle_scope, &*global_context);
+    let context = v8::Local::new(handle_scope, context_global);
     let scope = &mut v8::ContextScope::new(handle_scope, context);
 
     let req_obj = v8::Object::new(scope);
 
+    let req_id_key = v8_str(scope, "__titan_request_id");
+    let req_id_val = v8::Integer::new(scope, request_id as i32);
+    req_obj.set(scope, req_id_key.into(), req_id_val.into());
+
     let m_key = v8_str(scope, "method");
     let m_val = v8_str(scope, req_method);
     req_obj.set(scope, m_key.into(), m_val.into());
@@ -298,17 +403,34 @@ pub fn execute_action_optimized(
         global.set(scope, tr_act_key.into(), tr_act_val.into());
         let try_catch = &mut v8::TryCatch::new(scope);
 
-        if let Some(result) = action_fn.call(try_catch, global.into(), &[req_obj.into()]) {
-            return v8_to_json(try_catch, result);
+        if let Some(_) = action_fn.call(try_catch, global.into(), &[req_obj.into()]) {
+            return;
         }
-
+        
         let msg = try_catch
             .message()
             .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
             .unwrap_or("Unknown error".to_string());
-        return serde_json::json!({"error": msg});
+        
+        if msg.contains("SUSPEND") {
+            return;
+        }
+
+        println!("[Isolate {}] Action Error: {}", runtime.id, msg);
+        if let Some(tx) = runtime.pending_requests.remove(&request_id) {
+             let _ = tx.send(crate::runtime::WorkerResult { 
+                 json: serde_json::json!({"error": msg}),
+                 timings: vec![]
+             });
+        }
+    } else {
+        if let Some(tx) = runtime.pending_requests.remove(&request_id) {
+             let _ = tx.send(crate::runtime::WorkerResult { 
+                 json: serde_json::json!({"error": format!("Action '{}' not found", action_name)}),
+                 timings: vec![]
+             });
+        }
     }
-    serde_json::json!({"error": format!("Action '{}' not found", action_name)})
 }
 
 pub fn v8_str<'s>(scope: &mut v8::HandleScope<'s>, s: &str) -> v8::Local<'s, v8::String> {

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

@@ -1,22 +1,186 @@
-
 // Titan Core Runtime JS
-// This is embedded in the binary for ultra-fast startup.
+// Safe Bootstrap — runs only once
+if (!globalThis.__TITAN_CORE_LOADED__) {
+    globalThis.__TITAN_CORE_LOADED__ = true;
+
+    globalThis.global = globalThis;
+
+    // ensure t exists early
+    if (!globalThis.t) globalThis.t = {};
+
+    // -----------------------------
+    // defineAction identity helper
+    // -----------------------------
+    globalThis.defineAction = (fn) => {
+        if (fn.__titanWrapped) return fn;
+
+        const wrapped = function (req) {
+            const requestId = req.__titan_request_id;
+
+            const isSuspend = (err) => {
+                const msg = err && (err.message || String(err));
+                return msg && (msg.includes("__SUSPEND__") || msg.includes("SUSPEND"));
+            };
 
-globalThis.global = globalThis;
+            try {
+                const result = fn(req);
 
-// defineAction identity helper
-globalThis.defineAction = (fn) => fn;
+                if (result && typeof result.then === 'function') {
+                    result.then(
+                        (data) => {
+                            t._finish_request(requestId, data);
+                        },
+                        (err) => {
+                            if (isSuspend(err)) return;
+                            t._finish_request(requestId, { error: err.message || String(err) });
+                        }
+                    );
+                } else {
+                    t._finish_request(requestId, result);
+                }
+            } catch (err) {
+                if (isSuspend(err)) return;
+                t._finish_request(requestId, { error: err.message || String(err) });
+            }
+        };
 
-// TextDecoder Polyfill using native t.decodeUtf8
-globalThis.TextDecoder = class TextDecoder {
-    decode(buffer) {
-        return t.decodeUtf8(buffer);
+        wrapped.__titanWrapped = true;
+        return wrapped;
+    };
+
+
+    // -----------------------------
+    // TextDecoder Polyfill
+    // -----------------------------
+    globalThis.TextDecoder = class TextDecoder {
+        decode(buffer) {
+            return t.decodeUtf8(buffer);
+        }
+    };
+
+    // -----------------------------
+    // process.env
+    // -----------------------------
+    globalThis.process = {
+        env: t.loadEnv ? t.loadEnv() : {}
+    };
+
+    // -----------------------------
+    // Async Proxy Creator
+    // -----------------------------
+    function createAsyncOp(op) {
+        return new Proxy(op, {
+            get(target, prop) {
+                if (
+                    prop === "__titanAsync" ||
+                    prop === "type" ||
+                    prop === "data" ||
+                    typeof prop === 'symbol'
+                ) {
+                    return target[prop];
+                }
+
+                throw new Error(
+                    `[Titan Error] Accessed '${String(prop)}' without drift(). ` +
+                    `Fix: const res = drift(t.fetch(...));`
+                );
+            }
+        });
     }
-};
 
-// Process environment variables
-globalThis.process = {
-    env: t.loadEnv()
-};
+    // -----------------------------
+    // Response API
+    // -----------------------------
+    const titanResponse = {
+        json(data, status = 200, extraHeaders = {}) {
+            return {
+                _isResponse: true,
+                status,
+                headers: { "Content-Type": "application/json", ...extraHeaders },
+                body: JSON.stringify(data)
+            };
+        },
+        text(data, status = 200, extraHeaders = {}) {
+            return {
+                _isResponse: true,
+                status,
+                headers: { "Content-Type": "text/plain", ...extraHeaders },
+                body: String(data)
+            };
+        },
+        html(data, status = 200, extraHeaders = {}) {
+            return {
+                _isResponse: true,
+                status,
+                headers: { "Content-Type": "text/html", ...extraHeaders },
+                body: String(data)
+            };
+        },
+        redirect(url, status = 302, extraHeaders = {}) {
+            return {
+                _isResponse: true,
+                status,
+                headers: { "Location": url, ...extraHeaders },
+                redirect: url
+            };
+        }
+    };
+
+    t.response = titanResponse;
+
+    // -----------------------------
+    // Drift Support
+    // -----------------------------
+    globalThis.drift = function (value) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (!item || !item.__titanAsync) {
+                    throw new Error("drift() array must contain async ops only.");
+                }
+            }
+        } else if (!value || !value.__titanAsync) {
+            throw new Error("drift() must wrap async ops.");
+        }
+
+        return t._drift_call(value);
+    };
+
+    // -----------------------------
+    // Safe Wrappers
+    // -----------------------------
+
+    // fetch
+    if (t.fetch && !t.fetch.__titanWrapped) {
+        const nativeFetch = t.fetch;
+        t.fetch = function (...args) {
+            return createAsyncOp(nativeFetch(...args));
+        };
+        t.fetch.__titanWrapped = true;
+    }
+
+    // db.connect
+    if (t.db && !t.db.__titanWrapped) {
+        const nativeDbConnect = t.db.connect;
+
+        t.db.connect = function (connString) {
+            const conn = nativeDbConnect(connString);
+
+            if (!conn.query.__titanWrapped) {
+                const nativeQuery = conn.query;
+                conn.query = (sql) => {
+                    return createAsyncOp({
+                        __titanAsync: true,
+                        type: "db_query",
+                        data: { conn: connString, query: sql }
+                    });
+                };
+                conn.query.__titanWrapped = true;
+            }
+
+            return conn;
+        };
+
+        t.db.__titanWrapped = true;
+    }
 
-// Everything is strictly synchronous and request-driven.
+}