feat(cat-gateway): Catalyst singed Documents indexing POST endpoint

catalyst-gateway/bin/src/db/event/common/eq_or_ranged_uuid.rs

@@ -0,0 +1,27 @@
+//! `EqOrRangedUuid` query conditional stmt object.
+
+/// Search either by a singe UUID, or a Range of UUIDs
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum EqOrRangedUuid {
+    /// Search by the exact UUID
+    Eq(uuid::Uuid),
+    /// Search in this UUID's range
+    Range {
+        /// Minimum UUID to find (inclusive)
+        min: uuid::Uuid,
+        /// Maximum UUID to find (inclusive)
+        max: uuid::Uuid,
+    },
+}
+
+impl EqOrRangedUuid {
+    /// Return a sql conditional statement by the provided `table_field`
+    pub(crate) fn conditional_stmt(&self, table_field: &str) -> String {
+        match self {
+            Self::Eq(id) => format!("{table_field} = '{id}'"),
+            Self::Range { min, max } => {
+                format!("{table_field} >= '{min}' AND {table_field} <= '{max}'")
+            },
+        }
+    }
+}

catalyst-gateway/bin/src/db/event/common/mod.rs

@@ -1,3 +1,4 @@
 //! Reusable common database objects
 
+pub(crate) mod eq_or_ranged_uuid;
 pub(crate) mod query_limits;

catalyst-gateway/bin/src/db/event/common/query_limits.rs

@@ -1,7 +1,5 @@
 //! `QueryLimits` query argument object.
 
-#![allow(dead_code)]
-
 use std::fmt::Display;
 
 use crate::service::common::types::generic::query::pagination::{Limit, Page};
@@ -33,27 +31,38 @@ impl Display for QueryLimits {
 
 impl QueryLimits {
     /// Create a `QueryLimits` object without the any limits.
+    #[allow(dead_code)]
     pub(crate) const ALL: QueryLimits = Self(QueryLimitsInner::All);
     /// Create a `QueryLimits` object with the limit equals to `1`.
+    #[allow(dead_code)]
     pub(crate) const ONE: QueryLimits = Self(QueryLimitsInner::Limit(1));
 
     /// Create a `QueryLimits` object from the service `Limit` and `Page` values.
     ///
     /// # Errors
-    ///  - Invalid `limit` value, must be more than `0`.
     ///  - Invalid arguments, `limit` must be provided when `page` is not None.
-    pub(crate) fn new(limit: Option<Limit>, page: Option<Page>) -> anyhow::Result<Self> {
+    pub(crate) fn new(limit: Option<Limit>, page: Option<Page>) -> Self {
         match (limit, page) {
             (Some(limit), Some(page)) => {
-                Ok(Self(QueryLimitsInner::LimitAndOffset(
+                Self(QueryLimitsInner::LimitAndOffset(limit.into(), page.into()))
+            },
+            (Some(limit), None) => {
+                Self(QueryLimitsInner::LimitAndOffset(
                     limit.into(),
+                    Page::default().into(),
+                ))
+            },
+            (None, Some(page)) => {
+                Self(QueryLimitsInner::LimitAndOffset(
+                    Limit::default().into(),
                     page.into(),
-                )))
+                ))
             },
-            (Some(limit), None) => Ok(Self(QueryLimitsInner::Limit(limit.into()))),
-            (None, None) => Ok(Self(QueryLimitsInner::All)),
-            (None, Some(_)) => {
-                anyhow::bail!("Invalid arguments, `limit` must be provided when `page` is not None")
+            (None, None) => {
+                Self(QueryLimitsInner::LimitAndOffset(
+                    Limit::default().into(),
+                    Page::default().into(),
+                ))
             },
         }
     }

catalyst-gateway/bin/src/db/event/signed_docs/full_signed_doc.rs

@@ -51,6 +51,12 @@ impl FullSignedDoc {
         self.body.authors()
     }
 
+    /// Returns the document metadata.
+    #[allow(dead_code)]
+    pub(crate) fn metadata(&self) -> Option<&serde_json::Value> {
+        self.body.metadata()
+    }
+
     /// Returns the `SignedDocBody`.
     #[allow(dead_code)]
     pub(crate) fn body(&self) -> &SignedDocBody {

catalyst-gateway/bin/src/db/event/signed_docs/query_filter.rs

@@ -2,31 +2,90 @@
 
 use std::fmt::Display;
 
+use crate::db::event::common::eq_or_ranged_uuid::EqOrRangedUuid;
+
 /// A `select_signed_docs` query filtering argument.
-#[allow(dead_code)]
-pub(crate) enum DocsQueryFilter {
-    /// All entries
-    All,
-    /// Select docs with the specific `type` field
-    DocType(uuid::Uuid),
-    /// Select docs with the specific `id` field
-    DocId(uuid::Uuid),
-    /// Select docs with the specific `id` and `ver` field
-    DocVer(uuid::Uuid, uuid::Uuid),
-    /// Select docs with the specific `authors` field
-    Author(String),
+/// If all fields would be `None` the query will search for all entries from the db.
+#[derive(Clone, Debug)]
+pub(crate) struct DocsQueryFilter {
+    /// `type` field
+    doc_type: Option<uuid::Uuid>,
+    /// `id` field
+    id: Option<EqOrRangedUuid>,
+    /// `ver` field
+    ver: Option<EqOrRangedUuid>,
+    /// `metadata` field
+    metadata: Option<serde_json::Value>,
 }
 
 impl Display for DocsQueryFilter {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::All => write!(f, "TRUE"),
-            Self::DocType(doc_type) => write!(f, "signed_docs.type = '{doc_type}'"),
-            Self::DocId(id) => write!(f, "signed_docs.id = '{id}'"),
-            Self::DocVer(id, ver) => {
-                write!(f, "signed_docs.id = '{id}' AND signed_docs.ver = '{ver}'")
-            },
-            Self::Author(author) => write!(f, "signed_docs.authors @> '{{ \"{author}\" }}'"),
+        use std::fmt::Write;
+        let mut query = "TRUE".to_string();
+
+        if let Some(doc_type) = &self.doc_type {
+            write!(&mut query, " AND signed_docs.type = '{doc_type}'")?;
+        }
+
+        if let Some(id) = &self.id {
+            write!(&mut query, " AND {}", id.conditional_stmt("signed_docs.id"))?;
+        }
+        if let Some(ver) = &self.ver {
+            write!(
+                &mut query,
+                " AND {}",
+                ver.conditional_stmt("signed_docs.ver")
+            )?;
+        }
+        if let Some(metadata) = &self.metadata {
+            write!(&mut query, " AND signed_docs.metadata @> '{metadata}'",)?;
+        }
+
+        write!(f, "{query}")
+    }
+}
+
+impl DocsQueryFilter {
+    /// Creates an empty filter stmt, so the query will retrieve all entries from the db.
+    pub fn all() -> Self {
+        DocsQueryFilter {
+            doc_type: None,
+            id: None,
+            ver: None,
+            metadata: None,
+        }
+    }
+
+    /// Set the `type` field filter condition
+    pub fn with_type(self, doc_type: uuid::Uuid) -> Self {
+        DocsQueryFilter {
+            doc_type: Some(doc_type),
+            ..self
+        }
+    }
+
+    /// Set the `type` field filter condition
+    pub fn with_id(self, id: EqOrRangedUuid) -> Self {
+        DocsQueryFilter {
+            id: Some(id),
+            ..self
+        }
+    }
+
+    /// Set the `ver` field filter condition
+    pub fn with_ver(self, ver: EqOrRangedUuid) -> Self {
+        DocsQueryFilter {
+            ver: Some(ver),
+            ..self
+        }
+    }
+
+    /// Set the `metadata` field filter condition
+    #[allow(dead_code)]
+    pub fn with_metadata(self, metadata: serde_json::Value) -> Self {
+        DocsQueryFilter {
+            metadata: Some(metadata),
+            ..self
         }
     }
 }

catalyst-gateway/bin/src/db/event/signed_docs/signed_doc_body.rs

@@ -40,11 +40,21 @@ impl SignedDocBody {
         &self.ver
     }
 
+    /// Returns the document type.
+    pub(crate) fn doc_type(&self) -> &uuid::Uuid {
+        &self.doc_type
+    }
+
     /// Returns the document authors.
     pub(crate) fn authors(&self) -> &Vec<String> {
         &self.authors
     }
 
+    /// Returns the document metadata.
+    pub(crate) fn metadata(&self) -> Option<&serde_json::Value> {
+        self.metadata.as_ref()
+    }
+
     /// Returns all signed document fields for the event db queries
     pub(crate) fn postgres_db_fields(&self) -> [&(dyn tokio_postgres::types::ToSql + Sync); 5] {
         [