Fix bugs and bump crate version

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rexie"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["Devashish Dixit <[email protected]>"]
 license = "MIT/Apache-2.0"
 description = "Rexie is an easy-to-use, futures based wrapper around IndexedDB that compiles to webassembly"
@@ -9,15 +9,21 @@ repository = "https://github.com/devashishdxt/rexie"
 categories = ["asynchronous", "database", "wasm", "web-programming"]
 keywords = ["wasm", "indexeddb", "futures", "idb", "indexed"]
 readme = "README.md"
-include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md"]
+include = [
+    "Cargo.toml",
+    "src/**/*.rs",
+    "tests/**/*.rs",
+    "README.md",
+    "LICENSE_*",
+]
 edition = "2021"
 
 [lib]
 path = "src/lib.rs"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-idb = { version = "0.6.1", features = ["builder"] }
+idb = { version = "0.6.2", features = ["builder"] }
 thiserror = "1.0.61"
 wasm-bindgen = "0.2.92"
 

README.md

@@ -8,12 +8,12 @@ To use Rexie, you need to add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-rexie = "0.4"
+rexie = "0.6"
 ```
 
 ### Example
 
-To create a new database, you can use the `Rexie::builder` method:
+To create a new database, you can use the [`Rexie::builder`] method:
 
 ```rust
 use rexie::*;
@@ -39,14 +39,14 @@ async fn build_database() -> Result<Rexie> {
 
     // Check basic details of the database
     assert_eq!(rexie.name(), "test");
-    assert_eq!(rexie.version(), 1.0);
+    assert_eq!(rexie.version(), Ok(1));
     assert_eq!(rexie.store_names(), vec!["employees"]);
 
     Ok(rexie)
 }
 ```
 
-To add an employee, you can use the `Store::add` method after creating a `Transaction`:
+To add an employee, you can use the [`Store::add`] method after creating a [`Transaction`]:
 
 ```rust
 use rexie::*;
@@ -77,7 +77,7 @@ async fn add_employee(rexie: &Rexie, name: &str, email: &str) -> Result<u32> {
 }
 ```
 
-To get an employee, you can use the `Store::get` method after creating a `Transaction`:
+To get an employee, you can use the [`Store::get`] method after creating a [`Transaction`]:
 
 ```rust
 use rexie::*;
@@ -90,7 +90,7 @@ async fn get_employee(rexie: &Rexie, id: u32) -> Result<Option<serde_json::Value
     let employees = transaction.store("employees")?;
 
     // Get the employee
-    let employee = employees.get(&id.into()).await?;
+    let employee = employees.get(id.into()).await?.unwrap();
 
     // Convert it to `serde_json::Value` from `JsValue`
     let employee: Option<serde_json::Value> = serde_wasm_bindgen::from_value(employee).unwrap();

src/error.rs

@@ -7,9 +7,6 @@ pub type Result<T> = std::result::Result<T, Error>;
 #[derive(Debug, Error, PartialEq)]
 #[non_exhaustive]
 pub enum Error {
-    /// Couldn't open a cursor
-    #[error("couldn't open a cursor")]
-    CursorNotFound,
     /// Indexed DB error
     #[error("idb error")]
     IdbError(#[from] idb::Error),

src/lib.rs

@@ -6,7 +6,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! rexie = "0.4"
+//! rexie = "0.6"
 //! ```
 //!
 //! ## Example
@@ -37,7 +37,7 @@
 //!
 //!     // Check basic details of the database
 //!     assert_eq!(rexie.name(), "test");
-//!     assert_eq!(rexie.version(), 1.0);
+//!     assert_eq!(rexie.version(), Ok(1));
 //!     assert_eq!(rexie.store_names(), vec!["employees"]);
 //!
 //!     Ok(rexie)
@@ -88,7 +88,7 @@
 //!     let employees = transaction.store("employees")?;
 //!     
 //!     // Get the employee
-//!     let employee = employees.get(&id.into()).await?.unwrap();
+//!     let employee = employees.get(id.into()).await?.unwrap();
 //!
 //!     // Convert it to `serde_json::Value` from `JsValue`
 //!     let employee: Option<serde_json::Value> = serde_wasm_bindgen::from_value(employee).unwrap();

src/transaction/index.rs

@@ -1,7 +1,7 @@
 use idb::Index;
 use wasm_bindgen::JsValue;
 
-use crate::{Direction, Error, KeyRange, Result};
+use crate::{Direction, KeyRange, Result};
 
 /// Index of an object store.
 pub struct StoreIndex {
@@ -62,49 +62,60 @@ impl StoreIndex {
         offset: Option<u32>,
         direction: Option<Direction>,
     ) -> Result<Vec<(JsValue, JsValue)>> {
-        let mut cursor = self
+        let cursor = self
             .index
             .open_cursor(key_range.map(Into::into), direction)?
-            .await?
-            .ok_or(Error::CursorNotFound)?
-            .into_managed();
-
-        let mut result = Vec::new();
-
-        match limit {
-            Some(limit) => {
-                if let Some(offset) = offset {
-                    cursor.advance(offset).await?;
-                }
-
-                for _ in 0..limit {
-                    let key = cursor.key()?;
-                    let value = cursor.value()?;
-
-                    match (key, value) {
-                        (Some(key), Some(value)) => result.push((key, value)),
-                        _ => break,
+            .await?;
+
+        match cursor {
+            None => Ok(Vec::new()),
+            Some(cursor) => {
+                let mut cursor = cursor.into_managed();
+
+                let mut result = Vec::new();
+
+                match limit {
+                    Some(limit) => {
+                        if let Some(offset) = offset {
+                            cursor.advance(offset).await?;
+                        }
+
+                        for _ in 0..limit {
+                            let key = cursor.key()?;
+                            let value = cursor.value()?;
+
+                            match (key, value) {
+                                (Some(key), Some(value)) => {
+                                    result.push((key, value));
+                                    cursor.next(None).await?;
+                                }
+                                _ => break,
+                            }
+                        }
                     }
-                }
-            }
-            None => {
-                if let Some(offset) = offset {
-                    cursor.advance(offset).await?;
-                }
-
-                loop {
-                    let key = cursor.key()?;
-                    let value = cursor.value()?;
-
-                    match (key, value) {
-                        (Some(key), Some(value)) => result.push((key, value)),
-                        _ => break,
+                    None => {
+                        if let Some(offset) = offset {
+                            cursor.advance(offset).await?;
+                        }
+
+                        loop {
+                            let key = cursor.key()?;
+                            let value = cursor.value()?;
+
+                            match (key, value) {
+                                (Some(key), Some(value)) => {
+                                    result.push((key, value));
+                                    cursor.next(None).await?;
+                                }
+                                _ => break,
+                            }
+                        }
                     }
                 }
+
+                Ok(result)
             }
         }
-
-        Ok(result)
     }
 
     /// Counts the number of key value pairs in the store

src/transaction/store.rs

@@ -1,7 +1,7 @@
 use idb::ObjectStore;
 use wasm_bindgen::JsValue;
 
-use crate::{Direction, Error, KeyPath, KeyRange, Result, StoreIndex};
+use crate::{Direction, KeyPath, KeyRange, Result, StoreIndex};
 
 /// An object store.
 pub struct Store {
@@ -90,49 +90,60 @@ impl Store {
         offset: Option<u32>,
         direction: Option<Direction>,
     ) -> Result<Vec<(JsValue, JsValue)>> {
-        let mut cursor = self
+        let cursor = self
             .object_store
             .open_cursor(key_range.map(Into::into), direction)?
-            .await?
-            .ok_or(Error::CursorNotFound)?
-            .into_managed();
-
-        let mut result = Vec::new();
-
-        match limit {
-            Some(limit) => {
-                if let Some(offset) = offset {
-                    cursor.advance(offset).await?;
-                }
-
-                for _ in 0..limit {
-                    let key = cursor.key()?;
-                    let value = cursor.value()?;
-
-                    match (key, value) {
-                        (Some(key), Some(value)) => result.push((key, value)),
-                        _ => break,
+            .await?;
+
+        match cursor {
+            None => Ok(Vec::new()),
+            Some(cursor) => {
+                let mut cursor = cursor.into_managed();
+
+                let mut result = Vec::new();
+
+                match limit {
+                    Some(limit) => {
+                        if let Some(offset) = offset {
+                            cursor.advance(offset).await?;
+                        }
+
+                        for _ in 0..limit {
+                            let key = cursor.key()?;
+                            let value = cursor.value()?;
+
+                            match (key, value) {
+                                (Some(key), Some(value)) => {
+                                    result.push((key, value));
+                                    cursor.next(None).await?;
+                                }
+                                _ => break,
+                            }
+                        }
                     }
-                }
-            }
-            None => {
-                if let Some(offset) = offset {
-                    cursor.advance(offset).await?;
-                }
-
-                loop {
-                    let key = cursor.key()?;
-                    let value = cursor.value()?;
-
-                    match (key, value) {
-                        (Some(key), Some(value)) => result.push((key, value)),
-                        _ => break,
+                    None => {
+                        if let Some(offset) = offset {
+                            cursor.advance(offset).await?;
+                        }
+
+                        loop {
+                            let key = cursor.key()?;
+                            let value = cursor.value()?;
+
+                            match (key, value) {
+                                (Some(key), Some(value)) => {
+                                    result.push((key, value));
+                                    cursor.next(None).await?;
+                                }
+                                _ => break,
+                            }
+                        }
                     }
                 }
+
+                Ok(result)
             }
         }
-
-        Ok(result)
     }
 
     /// Adds a key value pair in the store. Note that the key can be `None` if store has auto increment enabled.

tests/web.rs

@@ -342,10 +342,6 @@ async fn test_db_duplicate_add_fail() {
     // Write a duplicate value (with same email) to the database.
     let id = add_employee(&rexie, "John Doe New", "[email protected]").await;
     assert!(id.is_err());
-    let err = id.unwrap_err();
-    assert!(err
-        .to_string()
-        .starts_with("failed to execute indexed db request: ConstraintError"));
 
     close_and_delete_db(rexie).await;
 }