HACK

Author: penberg

index.d.ts

@@ -39,12 +39,14 @@ export declare class Database {
 export declare class Statement {
   columns(): unknown[]
   iterate(params?: unknown | undefined | null): object
-  iterateSync(params?: unknown | undefined | null): object
+  iterateSync(params?: unknown | undefined | null): RowsIterator
   run(params?: unknown | undefined | null): RunResult
   pluck(pluck?: boolean | undefined | null): this
   raw(raw?: boolean | undefined | null): this
   get(params?: unknown | undefined | null): unknown
   safeIntegers(toggle?: boolean | undefined | null): this
   interrupt(): void
 }
-export declare class RowsIterator { }
+export declare class RowsIterator {
+  next(): object
+}

src/lib.rs

@@ -614,7 +614,7 @@ impl Statement {
         &self,
         env: Env,
         params: Option<napi::JsUnknown>,
-    ) -> Result<napi::JsObject> {
+    ) -> Result<RowsIterator> {
         let rt = runtime()?;
         let safe_ints = self.safe_ints.load(Ordering::SeqCst);
         let raw = self.raw.load(Ordering::SeqCst);
@@ -766,7 +766,12 @@ impl Statement {
 }
 
 #[napi]
-pub struct RowsIterator {}
+pub struct RowsIterator {
+    rows: Arc<tokio::sync::Mutex<libsql::Rows>>,
+    safe_ints: bool,
+    raw: bool,
+    pluck: bool,
+}
 
 #[napi]
 impl RowsIterator {
@@ -776,42 +781,37 @@ impl RowsIterator {
         safe_ints: bool,
         raw: bool,
         pluck: bool,
-    ) -> Result<napi::JsObject> {
-        let mut iter = env.create_object()?;
-        let next_fn: JsFunction = env.create_function_from_closure("next", move |ctx| {
-            let rt = runtime()?;
-            let rows = rows.clone();
-            rt.block_on(async move {
-                let mut rows = rows.lock().await;
-                let next_row = rows.next().await.map_err(Error::from)?;
-                let mut result = ctx.env.create_object()?;
-                match next_row {
-                    Some(row) => {
-                        let value = map_row(&ctx.env, &rows, &row, safe_ints, raw, pluck)?;
-                        result.set_named_property("value", value)?;
-                        result.set_named_property("done", ctx.env.get_boolean(false)?)?;
-                    }
-                    None => {
-                        result.set_named_property("done", ctx.env.get_boolean(true)?)?;
-                    }
-                }
-                Ok(result)
-            })
-        })?;
-        iter.set_named_property("next", next_fn)?;
-        // 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")?;
-        let symbol_ctor_obj = symbol_ctor.coerce_to_object()?;
-        let symbol_iterator = symbol_ctor_obj.get_named_property::<napi::JsSymbol>("iterator")?;
-        // Attach [Symbol.iterator]
-        iter.set_property(symbol_iterator, iterator_fn)?;
+    ) -> Result<Self> {
+        let iter = RowsIterator {
+            rows,
+            safe_ints,
+            raw,
+            pluck,
+        };
         Ok(iter)
     }
+
+    #[napi]
+    pub fn next(&self, env: Env) -> Result<napi::JsObject> {
+        let rt = runtime()?;
+        let rows = self.rows.clone();
+        rt.block_on(async move {
+            let mut rows = rows.lock().await;
+            let next_row = rows.next().await.map_err(Error::from)?;
+            let mut result = env.create_object()?;
+            match next_row {
+                Some(row) => {
+                    let value = map_row(&env, &rows, &row, self.safe_ints, self.raw, self.pluck)?;
+                    result.set_named_property("value", value)?;
+                    result.set_named_property("done", env.get_boolean(false)?)?;
+                }
+                None => {
+                    result.set_named_property("done", env.get_boolean(true)?)?;
+                }
+            }
+            Ok(result)
+        })
+}
 }
 
 fn runtime() -> Result<&'static Runtime> {