[FEATURE] Pagination logic implemented.

Author: Rafael Ruiz

src/domain/collection/collection_data.rs

@@ -0,0 +1,34 @@
+use crate::domain::document::document_data::DocumentData;
+
+pub struct CollectionData {
+    total: usize,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    documents: Vec<DocumentData>
+}
+
+impl CollectionData {
+    
+    pub fn new(total: usize, limit: Option<usize>, offset: Option<usize>, documents: Vec<DocumentData>) -> Self {
+        Self {
+            total, limit, offset, documents
+        }
+    }
+
+    pub fn total(&self) -> usize {
+        self.total
+    }
+
+    pub fn limit(&self) -> Option<usize> {
+        self.limit
+    }
+
+    pub fn offset(&self) -> Option<usize> {
+        self.offset
+    }
+
+    pub fn documents(&self) -> Vec<DocumentData> {
+        self.documents.clone()
+    }
+
+}

src/domain/filter/collection_query.rs

@@ -0,0 +1,23 @@
+#[derive(Clone)]
+pub struct CollectionQuery {
+    data_base: String,
+    collection: String
+}
+
+impl CollectionQuery {
+    
+    pub fn from(data_base: String, collection: String) -> Self {
+        Self {
+            data_base, collection
+        }
+    }
+
+    pub fn data_base(&self) -> String {
+        return self.data_base.clone();
+    }
+
+    pub fn collection(&self) -> String {
+        return self.collection.clone();
+    }
+
+}

src/domain/filter/data_base_query.rs

@@ -1,48 +1,18 @@
-use super::filter_element::FilterElement;
-
 #[derive(Clone)]
 pub struct DataBaseQuery {
     data_base: String,
-    collection: String,
-    filter: Option<FilterElement>
 }
 
 impl DataBaseQuery {
 
-    pub fn from(data_base: String, collection: String) -> DataBaseQuery {
-        DataBaseQuery {
-            data_base: data_base,
-            collection: collection,
-            filter: None
-        }
-    }
-
-    pub fn from_data_base(data_base: String) -> DataBaseQuery {
-        DataBaseQuery {
-            data_base: data_base,
-            collection: String::new(),
-            filter: None
-        }
-    }
-
-    pub fn from_filter(data_base: String, collection: String, filter: FilterElement) -> DataBaseQuery {
-        DataBaseQuery {
-            data_base: data_base,
-            collection: collection,
-            filter: Some(filter)
+    pub fn from(data_base: String) -> Self {
+        Self {
+            data_base
         }
     }
 
     pub fn data_base(&self) -> String {
         return self.data_base.clone();
     }
 
-    pub fn collection(&self) -> String {
-        return self.collection.clone();
-    }
-
-    pub fn filter(&self) -> Option<FilterElement> {
-        return self.filter.clone();
-    }
-
 }

src/domain/filter/document_query.rs

@@ -0,0 +1,48 @@
+use super::filter_element::FilterElement;
+
+#[derive(Clone)]
+pub struct DocumentQuery {
+    data_base: String,
+    collection: String,
+    skip: Option<usize>,
+    limit: Option<usize>,
+    filter: Option<FilterElement>
+}
+
+impl DocumentQuery {
+
+    pub fn from_filter(data_base: String, collection: String, filter: FilterElement) -> Self {
+        Self::from(data_base, collection, None, None, Some(filter))
+    }
+    
+    pub fn from(data_base: String, collection: String, skip: Option<usize>, limit: Option<usize>, filter: Option<FilterElement>) -> Self {
+        Self {
+            data_base: data_base,
+            collection: collection,
+            limit: limit,
+            skip: skip,
+            filter: filter
+        }
+    }
+
+    pub fn data_base(&self) -> String {
+        return self.data_base.clone();
+    }
+
+    pub fn collection(&self) -> String {
+        return self.collection.clone();
+    }
+
+    pub fn skip(&self) -> Option<usize> {
+        return self.skip;
+    }
+
+    pub fn limit(&self) -> Option<usize> {
+        return self.limit;
+    }
+
+    pub fn filter(&self) -> Option<FilterElement> {
+        return self.filter.clone();
+    }
+
+}

src/infrastructure/repository/i_db_repository.rs

@@ -4,12 +4,11 @@ use crate::{
     commons::exception::connect_exception::ConnectException,
     domain::{
         collection::{
-            collection_definition::CollectionDefinition,
-            generate_collection_query::GenerateCollectionQuery,
+            collection_data::CollectionData, collection_definition::CollectionDefinition, generate_collection_query::GenerateCollectionQuery
         },
         data_base::generate_database_query::GenerateDatabaseQuery,
         document::{document_data::DocumentData, document_schema::DocumentSchema},
-        filter::data_base_query::DataBaseQuery,
+        filter::{collection_query::CollectionQuery, data_base_query::DataBaseQuery, document_query::DocumentQuery},
         table::table_data_group::TableDataGroup,
     },
 };
@@ -26,23 +25,20 @@ pub trait IDBRepository: Clone + Send + Sync {
     async fn data_base_drop(&self, query: &GenerateDatabaseQuery) -> Result<String, ConnectException>;
 
     async fn collection_accept_schema(&self) -> Result<CollectionDefinition, ConnectException>;
-    async fn collection_metadata(&self, query: &DataBaseQuery) -> Result<Vec<TableDataGroup>, ConnectException>;
+    async fn collection_metadata(&self, query: &CollectionQuery) -> Result<Vec<TableDataGroup>, ConnectException>;
     async fn collection_find_all(&self, query: &DataBaseQuery) -> Result<Vec<String>, ConnectException>;
-    async fn collection_exists(&self, query: &DataBaseQuery) -> Result<bool, ConnectException>;
+    async fn collection_exists(&self, query: &CollectionQuery) -> Result<bool, ConnectException>;
     async fn collection_create(&self, query: &GenerateCollectionQuery) -> Result<String, ConnectException>;
     async fn collection_drop(&self, query: &GenerateCollectionQuery) -> Result<String, ConnectException>;
-    async fn collection_rename(&self, query: &DataBaseQuery, name: &str) -> Result<String, ConnectException>;
-    async fn collection_export(&self, query: &DataBaseQuery) -> Result<Vec<DocumentData>, ConnectException>;
-    async fn collection_import(&self, query: &DataBaseQuery, documents: Vec<String>) -> Result<String, ConnectException>;
-
-    async fn find_query_lite(&self, query: &DataBaseQuery) -> Result<Vec<String>, ConnectException>;
-    async fn find_query(&self, query: &DataBaseQuery) -> Result<Vec<DocumentData>, ConnectException>;
-
-    async fn find_all_lite(&self, query: &DataBaseQuery) -> Result<Vec<String>, ConnectException>;
-    async fn find_all(&self, query: &DataBaseQuery) -> Result<Vec<DocumentData>, ConnectException>;
-    async fn find(&self, query: &DataBaseQuery) -> Result<Option<DocumentData>, ConnectException>;
-    async fn schema(&self, query: &DataBaseQuery) -> Result<DocumentSchema, ConnectException>;
-    async fn insert(&self, query: &DataBaseQuery, value: &str) -> Result<DocumentData, ConnectException>;
-    async fn update(&self, query: &DataBaseQuery, value: &str) -> Result<Vec<DocumentData>, ConnectException>;
-    async fn delete(&self, query: &DataBaseQuery) -> Result<Vec<DocumentData>, ConnectException>;
+    async fn collection_rename(&self, query: &CollectionQuery, name: &str) -> Result<String, ConnectException>;
+    async fn collection_export(&self, query: &CollectionQuery) -> Result<Vec<DocumentData>, ConnectException>;
+    async fn collection_import(&self, query: &CollectionQuery, documents: Vec<String>) -> Result<String, ConnectException>;
+    
+    async fn find_all(&self, query: &DocumentQuery) -> Result<CollectionData, ConnectException>;
+    async fn find_query(&self, query: &DocumentQuery) -> Result<CollectionData, ConnectException>;
+    async fn find(&self, query: &DocumentQuery) -> Result<Option<DocumentData>, ConnectException>;
+    async fn schema(&self, query: &CollectionQuery) -> Result<DocumentSchema, ConnectException>;
+    async fn insert(&self, query: &CollectionQuery, value: &str) -> Result<DocumentData, ConnectException>;
+    async fn update(&self, query: &DocumentQuery, value: &str) -> Result<Vec<DocumentData>, ConnectException>;
+    async fn delete(&self, query: &DocumentQuery) -> Result<Vec<DocumentData>, ConnectException>;
 }