HACKS

Author: penberg

index.d.ts

@@ -48,6 +48,9 @@ export declare class Statement {
   interrupt(): void
 }
 export declare class RowsIterator {
-  next(): object
-  [Symbol.iterator](): this
+  next(): Record
+}
+export declare class Record {
+  get value(): unknown | null
+  get done(): boolean
 }

index.js

@@ -310,10 +310,11 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { SqliteError, Database, databasePrepareSync, Statement, RowsIterator } = nativeBinding
+const { SqliteError, Database, databasePrepareSync, Statement, RowsIterator, Record } = nativeBinding
 
 module.exports.SqliteError = SqliteError
 module.exports.Database = Database
 module.exports.databasePrepareSync = databasePrepareSync
 module.exports.Statement = Statement
 module.exports.RowsIterator = RowsIterator
+module.exports.Record = Record

src/lib.rs

@@ -7,8 +7,8 @@ mod auth;
 #[macro_use]
 extern crate napi_derive;
 
-use napi::bindgen_prelude::{Array, FromNapiValue, JsFunction};
-use napi::{Env, JsUnknown, Result, ValueType};
+use napi::bindgen_prelude::{Array, FromNapiValue};
+use napi::{Env, JsString, JsUnknown, Result, ValueType};
 use once_cell::sync::OnceCell;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -610,11 +610,7 @@ impl Statement {
     }
 
     #[napi]
-    pub fn iterate_sync(
-        &self,
-        env: Env,
-        params: Option<napi::JsUnknown>,
-    ) -> Result<RowsIterator> {
+    pub fn iterate_sync(&self, env: Env, params: Option<napi::JsUnknown>) -> Result<RowsIterator> {
         let rt = runtime()?;
         let safe_ints = self.safe_ints.load(Ordering::SeqCst);
         let raw = self.raw.load(Ordering::SeqCst);
@@ -792,28 +788,67 @@ impl RowsIterator {
     }
 
     #[napi]
-    pub fn next(&self, env: Env) -> Result<napi::JsObject> {
+    pub fn next(&self, env: Env) -> Result<Record> {
         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)
+            let record = match next_row {
+                Some(row) => Record {
+                    rows: self.rows.clone(),
+                    row: Some(row),
+                    safe_ints: self.safe_ints,
+                    raw: self.raw,
+                    pluck: self.pluck,
+                },
+                None => Record {
+                    rows: self.rows.clone(),
+                    row: None,
+                    safe_ints: self.safe_ints,
+                    raw: self.raw,
+                    pluck: self.pluck,
+                },
+            };
+            Ok(record)
         })
     }
 }
 
+#[napi]
+pub struct Record {
+    rows: Arc<tokio::sync::Mutex<libsql::Rows>>,
+    row: Option<libsql::Row>,
+    safe_ints: bool,
+    raw: bool,
+    pluck: bool,
+}
+
+#[napi]
+impl Record {
+    #[napi(getter)]
+    pub fn value(&self, env: Env) -> Option<napi::JsUnknown> {
+        if let Some(row) = &self.row {
+            let rt = runtime().unwrap();
+            let rows = self.rows.clone();
+            let value = rt
+                .block_on(async move {
+                    let rows = rows.lock().await;
+                    map_row(&env, &rows, &row, self.safe_ints, self.raw, self.pluck)
+                })
+                .unwrap();
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    #[napi(getter)]
+    pub fn done(&self) -> bool {
+        self.row.is_none()
+    }
+}
+
 fn runtime() -> Result<&'static Runtime> {
     static RUNTIME: OnceCell<Runtime> = OnceCell::new();