added generic error,

fixed sorting for tables with skipped fields

Author: maccesch

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.7.1] -
+
+### Changes
+
+- Added generic error type to `TableDataProvider`
+- Fixed sorting for tables with skipped fields
+
 ## [0.7.0] - 2024-02-08
 
 ### Features 🚀

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos-struct-table"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 authors = ["Marc-Stefan Cassola"]
 categories = ["gui", "web-programming"]
@@ -13,7 +13,7 @@ repository = "https://github.com/Synphonyte/leptos-struct-table"
 
 [dependencies]
 leptos = { version = "0.6", features = ["nightly"] }
-leptos-struct-table-macro = "0.9"
+leptos-struct-table-macro = "0.9.1"
 leptos-use = "0.10"
 async-trait = "0.1"
 paste = { version = "1.0", optional = true }

examples/paginated_rest_datasource/src/data_provider.rs

@@ -47,10 +47,10 @@ impl BookDataProvider {
         }
 
         format!(
-                "https://archive.org/advancedsearch.php?q=creator%3A%28Lewis%29&fl%5B%5D=creator&fl%5B%5D=identifier&fl%5B%5D=publicdate&fl%5B%5D=title{sort}&rows={}&page={}&output=json&callback=",
-                Self::PAGE_ROW_COUNT,
-                page_index + 1,
-            )
+            "https://archive.org/advancedsearch.php?q=creator%3A%28Lewis%29&fl%5B%5D=creator&fl%5B%5D=identifier&fl%5B%5D=publicdate&fl%5B%5D=title{sort}&rows={}&page={}&output=json&callback=",
+            Self::PAGE_ROW_COUNT,
+            page_index + 1,
+        )
     }
 }
 

examples/tailwind/src/main.rs

@@ -1,6 +1,5 @@
 mod tailwind;
 
-use async_trait::async_trait;
 use chrono::NaiveDate;
 use leptos::*;
 use leptos_struct_table::*;

src/components/table_content.rs

@@ -16,6 +16,8 @@ use leptos_use::{
 };
 use std::cell::RefCell;
 use std::collections::{HashSet, VecDeque};
+use std::fmt::Debug;
+use std::marker::PhantomData;
 use std::ops::Range;
 use std::rc::Rc;
 use wasm_bindgen::JsCast;
@@ -55,7 +57,7 @@ renderer_fn!(
 
 /// Render the content of a table. This is the main component of this crate.
 #[component]
-pub fn TableContent<Row, DataP, ClsP>(
+pub fn TableContent<Row, DataP, Err, ClsP>(
     /// The data to be rendered in this table.
     /// This must implement [`TableDataProvider`] or [`PaginatedTableDataProvider`].
     rows: DataP,
@@ -176,10 +178,13 @@ pub fn TableContent<Row, DataP, ClsP>(
     /// Please check [`DisplayStrategy`] to see explanations of all available options.
     #[prop(optional)]
     display_strategy: DisplayStrategy,
+
+    #[prop(optional)] _marker: PhantomData<Err>,
 ) -> impl IntoView
 where
     Row: TableRow<ClassesProvider = ClsP> + Clone + 'static,
-    DataP: TableDataProvider<Row> + 'static,
+    DataP: TableDataProvider<Row, Err> + 'static,
+    Err: Debug,
     ClsP: TableClassesProvider + Copy + 'static,
 {
     let on_change = store_value(on_change);
@@ -412,7 +417,11 @@ where
                     let set_known_row_count = set_known_row_count.clone();
 
                     async move {
-                        let result = rows.borrow().get_rows(missing_range.clone()).await;
+                        let result = rows
+                            .borrow()
+                            .get_rows(missing_range.clone())
+                            .await
+                            .map_err(|err| format!("{err:?}"));
                         if let Ok((_, loaded_range)) = &result {
                             if loaded_range.end < missing_range.end {
                                 set_known_row_count(missing_range.end);

src/data_provider.rs

@@ -1,6 +1,7 @@
 use crate::ColumnSort;
 use async_trait::async_trait;
 use std::collections::VecDeque;
+use std::fmt::Debug;
 use std::ops::Range;
 
 /// The trait that provides data for the `<TableContent>` component.
@@ -10,13 +11,16 @@ use std::ops::Range;
 /// this is automatically implemented for `Vec<Row>`.
 /// This way a simple list of items can be passed to the table.
 ///
-/// This is also automatically implemented for any struct that implements [`PaginatedTableDataProvider`]
-/// which is a more convenient way of connecting to a paginated data source.
+/// This is also automatically implemented for any struct that implements
+/// [`PaginatedTableDataProvider`] or [`ExactTableDataProvider`].
+/// The first is a more convenient way of connecting to a paginated data source and the second is
+/// more convenient if you know you're always going to return exactly the requested range (except maybe
+/// at the end of the data).
 ///
 /// Please note that because of the use of [`async-trait`](https://docs.rs/async-trait/latest/async_trait/)
 /// this documentation looks a bit cluttered.
-#[async_trait(?Send)]
-pub trait TableDataProvider<Row> {
+#[async_trait(? Send)]
+pub trait TableDataProvider<Row, Err: Debug = String> {
     /// If Some(...), data will be loaded in chunks of this size. This is useful for paginated data sources.
     /// If you have such a paginated data source, you probably want to implement `PaginatedTableDataProvider`
     /// instead of this trait.
@@ -36,7 +40,7 @@ pub trait TableDataProvider<Row> {
     ///
     /// In the case of an error the returned error `String` is going to be displayed in a
     /// in place of the failed rows.
-    async fn get_rows(&self, range: Range<usize>) -> Result<(Vec<Row>, Range<usize>), String>;
+    async fn get_rows(&self, range: Range<usize>) -> Result<(Vec<Row>, Range<usize>), Err>;
 
     /// The total number of rows in the table. Returns `None` if unknown (which is the default).
     async fn row_count(&self) -> Option<usize> {
@@ -64,16 +68,16 @@ pub trait TableDataProvider<Row> {
 /// > You do not have implement this trait if you're using pagination and you vice versa if you're not using pagination
 /// > you can still implement this trait. And in case if you use this trait together with pagination the
 /// > display row count can be different from the `PAGE_ROW_COUNT`.
-#[async_trait(?Send)]
-pub trait PaginatedTableDataProvider<Row> {
+#[async_trait(? Send)]
+pub trait PaginatedTableDataProvider<Row, Err: Debug = String> {
     /// How many rows per page
     const PAGE_ROW_COUNT: usize;
 
     /// Get all data rows for the table specified by the page index (starts a 0).
     ///
     /// If you return less than `PAGE_ROW_COUNT` rows, it is assumed that the end of the
     /// data has been reached.
-    async fn get_page(&self, page_index: usize) -> Result<Vec<Row>, String>;
+    async fn get_page(&self, page_index: usize) -> Result<Vec<Row>, Err>;
 
     /// The total number of rows in the table. Returns `None` if unknown (which is the default).
     ///
@@ -98,14 +102,15 @@ pub trait PaginatedTableDataProvider<Row> {
     }
 }
 
-#[async_trait(?Send)]
-impl<Row, D> TableDataProvider<Row> for D
+#[async_trait(? Send)]
+impl<Row, Err, D> TableDataProvider<Row, Err> for D
 where
-    D: PaginatedTableDataProvider<Row>,
+    D: PaginatedTableDataProvider<Row, Err>,
+    Err: Debug,
 {
     const CHUNK_SIZE: Option<usize> = Some(D::PAGE_ROW_COUNT);
 
-    async fn get_rows(&self, range: Range<usize>) -> Result<(Vec<Row>, Range<usize>), String> {
+    async fn get_rows(&self, range: Range<usize>) -> Result<(Vec<Row>, Range<usize>), Err> {
         let Range { start, end } = range;
         debug_assert_eq!(end - start, D::PAGE_ROW_COUNT);
 
@@ -116,11 +121,11 @@ where
     }
 
     async fn row_count(&self) -> Option<usize> {
-        PaginatedTableDataProvider::<Row>::row_count(self).await
+        PaginatedTableDataProvider::<Row, Err>::row_count(self).await
     }
 
     fn set_sorting(&mut self, sorting: &VecDeque<(usize, ColumnSort)>) {
-        PaginatedTableDataProvider::<Row>::set_sorting(self, sorting)
+        PaginatedTableDataProvider::<Row, Err>::set_sorting(self, sorting)
     }
 }