cleanups

Author: penberg

src/lib.rs

@@ -604,14 +604,13 @@ impl Statement {
                 let column_name = result.column_name(i).unwrap().to_string();
                 column_names.push(std::ffi::CString::new(column_name).unwrap());
             }
-            let iter = RowsIterator::new(
+            Ok(RowsIterator::new(
                 Arc::new(tokio::sync::Mutex::new(result)),
                 column_names,
                 safe_ints,
                 raw,
                 pluck,
-            )?;
-            Ok(iter)
+            ))
         })
     }
 
@@ -636,7 +635,9 @@ impl Statement {
             let rows = stmt.query(params).await.map_err(Error::from)?;
             let mut column_names = Vec::new();
             for i in 0..rows.column_count() {
-                column_names.push(std::ffi::CString::new(rows.column_name(i).unwrap().to_string()).unwrap());
+                column_names.push(
+                    std::ffi::CString::new(rows.column_name(i).unwrap().to_string()).unwrap(),
+                );
             }
             Ok::<_, napi::Error>((rows, column_names))
         };
@@ -727,7 +728,9 @@ impl Statement {
             let mut rows = stmt.query(params).await.map_err(Error::from)?;
             let mut column_names = Vec::new();
             for i in 0..rows.column_count() {
-                column_names.push(std::ffi::CString::new(rows.column_name(i).unwrap().to_string()).unwrap());
+                column_names.push(
+                    std::ffi::CString::new(rows.column_name(i).unwrap().to_string()).unwrap(),
+                );
             }
             let row = rows.next().await.map_err(Error::from)?;
             let duration = start.elapsed().as_secs_f64();
@@ -737,8 +740,9 @@ impl Statement {
                         let js_array = map_row_raw(&env, &column_names, &row, safe_ints, pluck)?;
                         Ok(js_array.into_unknown())
                     } else {
-                        let mut js_object = map_row_object(&env, &column_names, &row, safe_ints, pluck)?
-                            .coerce_to_object()?;
+                        let mut js_object =
+                            map_row_object(&env, &column_names, &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)?;
@@ -775,6 +779,7 @@ impl Statement {
     }
 }
 
+/// A raw iterator over rows. The JavaScript layer wraps this in a iterable.
 #[napi]
 pub struct RowsIterator {
     rows: Arc<tokio::sync::Mutex<libsql::Rows>>,
@@ -792,15 +797,14 @@ impl RowsIterator {
         safe_ints: bool,
         raw: bool,
         pluck: bool,
-    ) -> Result<Self> {
-        let iter = RowsIterator {
+    ) -> Self {
+        Self {
             rows,
             column_names,
             safe_ints,
             raw,
             pluck,
-        };
-        Ok(iter)
+        }
     }
 
     #[napi]
@@ -817,6 +821,7 @@ impl RowsIterator {
     }
 }
 
+/// Retrieve next row from an iterator synchronously. Needed for better-sqlite3 API compatibility.
 #[napi]
 pub fn iterator_next_sync(iter: &RowsIterator) -> Result<Record> {
     let rt = runtime()?;
@@ -837,7 +842,14 @@ impl Record {
     #[napi(getter)]
     pub fn value(&self, env: Env) -> napi::Result<napi::JsUnknown> {
         if let Some(row) = &self.row {
-            Ok(map_row(&env, &self.column_names, &row, self.safe_ints, self.raw, self.pluck)?)
+            Ok(map_row(
+                &env,
+                &self.column_names,
+                &row,
+                self.safe_ints,
+                self.raw,
+                self.pluck,
+            )?)
         } else {
             Ok(env.get_null()?.into_unknown())
         }