HACKS

Author: penberg

index.d.ts

@@ -39,6 +39,7 @@ export declare class Database {
 export declare class Statement {
   columns(): unknown[]
   iterate(params?: unknown | undefined | null): object
+  iterateSync(params?: unknown | undefined | null): object
   run(params?: unknown | undefined | null): RunResult
   pluck(pluck?: boolean | undefined | null): this
   raw(raw?: boolean | undefined | null): this

src/lib.rs

@@ -8,11 +8,11 @@ extern crate napi_derive;
 use napi::bindgen_prelude::{Array, FromNapiValue, JsFunction};
 use napi::{Env, JsUnknown, Result, ValueType};
 use once_cell::sync::OnceCell;
-use tracing_subscriber::{EnvFilter, filter::LevelFilter};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::{runtime::Runtime, sync::Mutex};
+use tracing_subscriber::{filter::LevelFilter, EnvFilter};
 
 #[napi]
 pub struct SqliteError {
@@ -579,7 +579,7 @@ impl Statement {
             let stmt = self.stmt.clone();
             rt.block_on(async move {
                 let mut stmt = stmt.lock().await;
-                stmt.reset();    
+                stmt.reset();
                 let params = if let Some(params) = params {
                     map_params(&stmt, Some(params)).unwrap()
                 } else {
@@ -593,13 +593,55 @@ impl Statement {
             let rows = stmt.lock().await.query(params).await.map_err(Error::from)?;
             Ok::<_, napi::Error>(rows)
         };
-        env.execute_tokio_future(
-            future,
-            move |&mut env, result| {
-                let iter = RowsIterator::new(env, Arc::new(tokio::sync::Mutex::new(result)), safe_ints, raw, pluck)?;
-                Ok(iter)
-            },
-        )
+        env.execute_tokio_future(future, move |&mut env, result| {
+            let iter = RowsIterator::new(
+                env,
+                Arc::new(tokio::sync::Mutex::new(result)),
+                safe_ints,
+                raw,
+                pluck,
+            )?;
+            Ok(iter)
+        })
+    }
+
+    #[napi]
+    pub fn iterate_sync(
+        &self,
+        env: Env,
+        params: Option<napi::JsUnknown>,
+    ) -> Result<napi::JsObject> {
+        let rt = runtime()?;
+        let safe_ints = self.safe_ints.load(Ordering::SeqCst);
+        let raw = self.raw.load(Ordering::SeqCst);
+        let pluck = self.pluck.load(Ordering::SeqCst);
+        let params = {
+            let stmt = self.stmt.clone();
+            rt.block_on(async move {
+                let mut stmt = stmt.lock().await;
+                stmt.reset();
+                let params = if let Some(params) = params {
+                    map_params(&stmt, Some(params)).unwrap()
+                } else {
+                    libsql::params::Params::None
+                };
+                params
+            })
+        };
+        let stmt = self.stmt.clone();
+        let future = async move {
+            let rows = stmt.lock().await.query(params).await.map_err(Error::from)?;
+            Ok::<_, napi::Error>(rows)
+        };
+        let rows = rt.block_on(future)?;
+        let iter = RowsIterator::new(
+            env,
+            Arc::new(tokio::sync::Mutex::new(rows)),
+            safe_ints,
+            raw,
+            pluck,
+        )?;
+        Ok(iter)
     }
 
     #[napi]
@@ -684,7 +726,8 @@ impl Statement {
                         let js_array = map_row_raw(&env, &rows, &row, safe_ints, pluck)?;
                         Ok(js_array.into_unknown())
                     } else {
-                        let mut js_object = map_row_object(&env, &rows, &row, safe_ints, pluck)?.coerce_to_object()?;
+                        let mut js_object = map_row_object(&env, &rows, &row, safe_ints, pluck)?
+                            .coerce_to_object()?;
                         let mut metadata = env.create_object()?;
                         let js_duration = env.create_double(duration)?;
                         metadata.set_named_property("duration", js_duration)?;
@@ -758,7 +801,7 @@ impl RowsIterator {
         // Create iterator function
         let iterator_fn: JsFunction = env.create_function_from_closure("iterator", move |ctx| {
             Ok(ctx.this::<napi::JsObject>())
-        })?;        
+        })?;
         // Get Symbol.iterator
         let global = env.get_global()?;
         let symbol_ctor = global.get_named_property::<JsFunction>("Symbol")?;
@@ -767,7 +810,7 @@ impl RowsIterator {
         // Attach [Symbol.iterator]
         iter.set_property(symbol_iterator, iterator_fn)?;
         Ok(iter)
-        }
+    }
 }
 
 fn runtime() -> Result<&'static Runtime> {
@@ -793,7 +836,11 @@ fn map_row(
     Ok(result)
 }
 
-fn convert_value_to_js(env: &Env, value: &libsql::Value, safe_ints: bool) -> Result<napi::JsUnknown> {
+fn convert_value_to_js(
+    env: &Env,
+    value: &libsql::Value,
+    safe_ints: bool,
+) -> Result<napi::JsUnknown> {
     match value {
         libsql::Value::Null => Ok(env.get_null()?.into_unknown()),
         libsql::Value::Integer(v) => {
@@ -895,11 +942,11 @@ static LOGGER_INIT: OnceCell<()> = OnceCell::new();
 fn ensure_logger() {
     LOGGER_INIT.get_or_init(|| {
         let _ = tracing_subscriber::fmt::fmt()
-        .with_env_filter(
-            EnvFilter::builder()
-                .with_default_directive(LevelFilter::ERROR.into())
-                .from_env_lossy(),
-        )
-        .try_init();
+            .with_env_filter(
+                EnvFilter::builder()
+                    .with_default_directive(LevelFilter::ERROR.into())
+                    .from_env_lossy(),
+            )
+            .try_init();
     });
 }

wrapper.js

@@ -254,7 +254,7 @@ class Statement {
    */
   iterate(...bindParameters) {
     try {
-      return this.stmt.iterate(...bindParameters);
+      return this.stmt.iterateSync(...bindParameters);
     } catch (err) {
       throw convertError(err);
     }