feat: add cache invalidations

Author: Randoooom

codegen/src/lib.rs

@@ -134,10 +134,14 @@ pub fn dynamic_cache(arguments: TokenStream, input: TokenStream) -> TokenStream
         })
         .collect::<Vec<Ident>>();
 
+    let invalidate = format_ident!("invalidate_{}", &sig.ident);
     let wrapper = format_ident!("__{}", &sig.ident);
     let skytable_tls = format_ident!("__{}_skytable_tls", &sig.ident);
+    let skytable_tls_static = format_ident!("{}", skytable_tls.to_string().to_uppercase());
     let skytable = format_ident!("__{}_skytable", &sig.ident);
+    let skytable_static = format_ident!("{}", skytable.to_string().to_uppercase());
     let memory = format_ident!("__{}_memory", &sig.ident);
+    let memory_static = format_ident!("{}", memory.to_string().to_uppercase());
 
     let mut wrapper_sig = sig.clone();
     wrapper_sig.ident = wrapper.clone();
@@ -251,6 +255,34 @@ pub fn dynamic_cache(arguments: TokenStream, input: TokenStream) -> TokenStream
             #memory(#(#args),*).await
         }
 
+        #vis async fn #invalidate(key: String) -> Result<()> {
+            use cached::Cached;
+            // check if the user did configure skytable
+            #[cfg(feature = "caching-skytable")]
+            if CONFIG.skytable_host().is_some() {
+                // now check if the user did configure tls
+                match CONFIG.skytable_certificate() {
+                    None => {
+                        // tls is inactive so we do use the raw tcp stream
+                        #skytable_static.get().unwrap().cache_remove(&key).await?;
+                    },
+                    Some(_) => {
+                        // tls is active so we use the tls cache
+                        #skytable_tls_static.get().unwrap().cache_remove(&key).await?;
+                    }
+                }
+            } else {
+                // otherwise use timed in memory caching
+                #memory_static.lock().await.cache_remove(&key);
+            }
+
+            #[cfg(not(feature = "caching-skytable"))]
+            #memory_static.lock().await.cache_remove(&key);
+
+
+            Ok(())
+        }
+
         // create the wrapper containing the original data logic
         #wrapper_sig #block
 

src/cache.rs

@@ -397,6 +397,19 @@ where
     }
 }
 
+#[macro_export]
+macro_rules! invalidate {
+    ($cache: ident, $key: expr) => {
+        paste! {{
+            let key = async { $key }.await;    
+
+            tokio::spawn(async move {
+                [<invalidate_ $cache>](key).await.unwrap();
+            });
+        }
+    }};
+}
+
 #[dynamic_cache(ttl = "300", key = r#"format!('prompt-{}', id)"#)]
 pub async fn fetch_prompt(connection: &DatabaseConnection, id: &str) -> Result<Option<Prompt>> {
     let result = database_request!(

src/error.rs

@@ -40,6 +40,9 @@ pub enum FeedbackFusionError {
     Unauthorized,
     #[error("{0}")]
     Forbidden(String),
+    #[cfg(feature = "caching-skytable")]
+    #[error(transparent)]
+    CacheError(#[from] crate::cache::SkytableCacheError)
 }
 
 impl From<ValidationErrors> for FeedbackFusionError {

src/main.rs

@@ -198,8 +198,7 @@ async fn main() {
 }
 
 pub mod prelude {
-    #[cfg(feature = "caching-skytable")]
-    pub use crate::{cache::*, skytable_configuration, skytable_configuration_tls};
+    pub use crate::{cache::*, skytable_configuration, skytable_configuration_tls, invalidate};
     pub use crate::{
         config::*,
         database::{DatabaseConfiguration, DatabaseConnection},

src/services/v1/field.rs

@@ -22,7 +22,9 @@
 
 use super::{FeedbackFusionV1Context, PublicFeedbackFusionV1Context};
 use crate::{
-    cache::fetch_prompt, database::schema::feedback::{Field, FieldOptions, FieldType}, prelude::*
+    cache::fetch_prompt,
+    database::schema::feedback::{Field, FieldOptions, FieldType},
+    prelude::*,
 };
 use feedback_fusion_common::proto::{
     CreateFieldRequest, DeleteFieldRequest, Field as ProtoField, FieldPage, GetFieldsRequest,
@@ -48,6 +50,8 @@ pub async fn create_field(
         .build();
     database_request!(Field::insert(connection, &field).await, "Insert field")?;
 
+    invalidate!(fields_by_prompt, format!("prompt-{}", field.prompt()));
+
     Ok(Response::new(field.into()))
 }
 
@@ -151,6 +155,8 @@ pub async fn update_field(
         "Update field by id"
     )?;
 
+    invalidate!(fields_by_prompt, format!("prompt-{}", field.prompt()));
+
     Ok(Response::new(field.into()))
 }
 

src/services/v1/prompt.rs

@@ -117,6 +117,9 @@ pub async fn update_prompt(
         Prompt::update_by_column(connection, &prompt, "id").await,
         "Update prompt"
     )?;
+
+    invalidate!(fetch_prompt, format!("prompt-{}", prompt.id()));
+
     Ok(Response::new(prompt.into()))
 }