async iteraertor

Author: penberg

index.d.ts

@@ -12,6 +12,7 @@ export interface RunResult {
   duration: number
   lastInsertRowid: number
 }
+export declare function iteratorNextSync(iter: RowsIterator): Record
 export declare class SqliteError {
   message: string
   code: string
@@ -48,7 +49,7 @@ export declare class Statement {
   interrupt(): void
 }
 export declare class RowsIterator {
-  next(): Record
+  next(): Promise<Record>
 }
 export declare class Record {
   get value(): unknown

index.js

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

integration-tests/tests/async.test.js

@@ -113,7 +113,7 @@ test.serial("Statement.iterate() [empty]", async (t) => {
 
   const stmt = await db.prepare("SELECT * FROM users WHERE id = 0");
   const it = await stmt.iterate();
-  t.is(it.next().done, true);
+  t.is((await it.next()).done, true);
 });
 
 test.serial("Statement.iterate()", async (t) => {
@@ -122,7 +122,7 @@ test.serial("Statement.iterate()", async (t) => {
   const stmt = await db.prepare("SELECT * FROM users");
   const expected = [1, 2];
   var idx = 0;
-  for (const row of await stmt.iterate()) {
+  for await (const row of await stmt.iterate()) {
     t.is(row.id, expected[idx++]);
   }
 });

promise.js

@@ -264,8 +264,18 @@ class Statement {
   async iterate(...bindParameters) {
     try {
       const it = await this.stmt.iterate(...bindParameters);
-      it[Symbol.iterator] = function() { return this; };
-      return it;
+      return {
+        next() {
+          return it.next();
+        },
+        [Symbol.asyncIterator]() {
+          return {
+            next() {
+              return it.next();
+            }
+          };
+        }
+      };
     } catch (err) {
       throw convertError(err);
     }
@@ -281,7 +291,7 @@ class Statement {
       const result = [];
       const iterator = await this.iterate(...bindParameters);
       let next;
-      while (!(next = iterator.next()).done) {
+      while (!(next = await iterator.next()).done) {
         result.push(next.value);
       }
       return result;

src/lib.rs

@@ -7,6 +7,7 @@ mod auth;
 #[macro_use]
 extern crate napi_derive;
 
+use libsql::Row;
 use napi::bindgen_prelude::{Array, FromNapiValue, ToNapiValue};
 use napi::{Env, JsUnknown, Result, ValueType};
 use once_cell::sync::OnceCell;
@@ -803,33 +804,40 @@ impl RowsIterator {
     }
 
     #[napi]
-    pub fn next(&self, env: Env) -> Result<Record> {
-        let rt = runtime()?;
+    pub async fn next(&self) -> Result<Record> {
+        let column_names = self.column_names.clone();
+        let safe_ints = self.safe_ints;
+        let raw = self.raw;
+        let pluck = self.pluck;
         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 record = match next_row {
-                Some(row) => Record {
-                    column_names: self.column_names.clone(),
-                    row: Some(row),
-                    safe_ints: self.safe_ints,
-                    raw: self.raw,
-                    pluck: self.pluck,
-                },
-                None => Record {
-                    column_names: self.column_names.clone(),
-                    row: None,
-                    safe_ints: self.safe_ints,
-                    raw: self.raw,
-                    pluck: self.pluck,
-                },
-            };
-            Ok(record)
-        })
+        let mut rows = rows.lock().await;
+        let next_row = rows.next().await.map_err(Error::from)?;
+        let record = match next_row {
+            Some(row) => Record {
+                column_names,
+                row: Some(row),
+                safe_ints,
+                raw,
+                pluck,
+            },
+            None => Record {
+                column_names,
+                row: None,
+                safe_ints,
+                raw,
+                pluck,
+            },
+        };
+        Ok(record)
     }
 }
 
+#[napi]
+pub fn iterator_next_sync(iter: &RowsIterator) -> Result<Record> {
+    let rt = runtime()?;
+    rt.block_on(async move { iter.next().await })
+}
+
 #[napi]
 pub struct Record {
     column_names: Vec<std::ffi::CString>,

wrapper.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { Database: NativeDb, databasePrepareSync } = require("./index.js");
+const { Database: NativeDb, databasePrepareSync, iteratorNextSync } = require("./index.js");
 const SqliteError = require("./sqlite-error.js");
 const Authorization = require("./auth");
 
@@ -264,8 +264,14 @@ class Statement {
   iterate(...bindParameters) {
     try {
       const it = this.stmt.iterateSync(...bindParameters);
-      it[Symbol.iterator] = function() { return this; };
-      return it;
+      return {
+        next: () => iteratorNextSync(it),
+        [Symbol.iterator]() {
+          return {
+            next: () => iteratorNextSync(it),
+          }
+        },
+      };
     } catch (err) {
       throw convertError(err);
     }