Introduce basic caching mechanism

Author: lucemans

engine/Cargo.lock

@@ -58,3 +58,5 @@ rust-s3 = { version = "0.36.0-beta.2", default-features = false, features = [
 aws-sdk-s3 = "1.64.0"
 aws-config = "1.5.10"
 async_zip = { version = "0.0.17", features = ["bzip2", "lzma", "zstd", "xz", "deflate"] }
+dashmap = { version = "6.1.0", features = ["serde"] }
+serde_json = "1.0.138"

engine/Cargo.toml

@@ -0,0 +1,59 @@
+use chrono::{DateTime, Duration, Utc};
+use dashmap::DashMap;
+use futures::future::{BoxFuture, Shared};
+use tracing::info;
+
+#[derive(Debug)]
+pub struct Cache {
+    pub raw: DashMap<String, Shared<BoxFuture<'static, CachedValue<serde_json::Value>>>>,
+}
+
+impl Cache {
+    pub fn new() -> Self {
+        Self {
+            raw: DashMap::new(),
+        }
+    }
+
+    pub async fn has(&self, key: &str) -> Option<serde_json::Value> {
+        if let Some(x) = self.raw.get(key) {
+            let x = x.clone().await;
+            info!("Cache hit: {}", key);
+
+            if x.is_expired() {
+                self.raw.remove(key);
+                return None;
+            }
+
+            Some(x.value)
+        } else {
+            info!("Cache miss: {}", key);
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CachedValue<T> {
+    pub value: T,
+    pub expires_at: DateTime<Utc>,
+}
+
+impl<T> CachedValue<T> {
+    pub fn new(value: T, expires_at: DateTime<Utc>) -> Self {
+        Self { value, expires_at }
+    }
+
+    pub fn new_with_ttl(value: T, ttl: Duration) -> Self {
+        Self {
+            value,
+            expires_at: Utc::now() + ttl,
+        }
+    }
+}
+
+impl<T> CachedValue<T> {
+    pub fn is_expired(&self) -> bool {
+        self.expires_at < Utc::now()
+    }
+}

engine/src/cache/mod.rs

@@ -8,6 +8,7 @@ pub mod routes;
 pub mod state;
 pub mod storage;
 pub mod utils;
+pub mod cache;
 
 #[async_std::main]
 async fn main() {

engine/src/main.rs

@@ -143,7 +143,7 @@ impl UserAuth {
     pub async fn required_member_of(&self, team_id: impl AsRef<str>) -> Result<(), HttpError> {
         match self {
             UserAuth::User(session, state) => {
-                if !Team::is_member(&state.database, &team_id, &session.user_id)
+                if !Team::is_member(&state, &team_id, &session.user_id)
                     .await
                     .map_err(HttpError::from)?
                 {

engine/src/middlewares/auth.rs

@@ -1,10 +1,11 @@
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, Duration, Utc};
+use futures::{future::Shared, FutureExt};
 use poem_openapi::Object;
 use serde::{Deserialize, Serialize};
 use sqlx::{query, query_as, query_scalar};
 
 use crate::{
-    database::Database, middlewares::auth::AccessibleResource, models::user::User, routes::error::HttpError, state::State, utils::id::{generate_id, IdType}
+    cache::CachedValue, database::Database, middlewares::auth::AccessibleResource, models::user::User, routes::error::HttpError, state::State, utils::id::{generate_id, IdType}
 };
 
 pub mod invite;
@@ -61,16 +62,10 @@ impl Team {
         .await
     }
 
-    pub async fn delete_by_id(
-        db: &Database,
-        team_id: impl AsRef<str>,
-    ) -> Result<(), sqlx::Error> {
-        query!(
-            "DELETE FROM teams WHERE team_id = $1",
-            team_id.as_ref()
-        )
-        .execute(&db.pool)
-        .await?;
+    pub async fn delete_by_id(db: &Database, team_id: impl AsRef<str>) -> Result<(), sqlx::Error> {
+        query!("DELETE FROM teams WHERE team_id = $1", team_id.as_ref())
+            .execute(&db.pool)
+            .await?;
 
         Ok(())
     }
@@ -92,18 +87,33 @@ impl Team {
     }
 
     pub async fn is_member(
-        db: &Database,
+        state: &State,
         team_id: impl AsRef<str>,
         user_id: impl AsRef<str>,
     ) -> Result<bool, sqlx::Error> {
-        Ok(query_scalar!(
+        let cache_key = format!("team:{}:member:{}", team_id.as_ref(), user_id.as_ref());
+
+        if let Some(x) = state.cache.has(&cache_key).await {
+            return Ok(x.as_bool().unwrap_or(false));
+        }
+
+        let x = query_scalar!(
             "SELECT EXISTS (SELECT 1 FROM user_teams WHERE team_id = $1 AND user_id = $2) OR EXISTS (SELECT 1 FROM teams WHERE team_id = $1 AND owner_id = $2)",
             team_id.as_ref(),
             user_id.as_ref()
         )
-        .fetch_one(&db.pool)
+        .fetch_one(&state.database.pool)
         .await?
-        .unwrap_or(false))
+        .unwrap_or(false);
+
+        state.cache.raw.insert(
+            cache_key,
+            async move { 
+                CachedValue::new_with_ttl(serde_json::Value::from(x), Duration::seconds(30))
+             }.boxed().shared(),
+        );
+
+        Ok(x)
     }
 
     pub async fn get_members(
@@ -124,7 +134,9 @@ pub struct TeamId<'a>(pub &'a str);
 
 impl<'a> AccessibleResource for TeamId<'a> {
     async fn has_access_to(&self, state: &State, user_id: &str) -> Result<bool, HttpError> {
-        let x = Team::is_member(&state.database, self.0, user_id).await.map_err(HttpError::from)?;  
+        let x = Team::is_member(&state, self.0, user_id)
+            .await
+            .map_err(HttpError::from)?;
 
         Ok(x)
     }

engine/src/models/team/mod.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use config::{Config, Environment};
 use serde::Deserialize;
 
-use crate::{database::Database, storage::Storage};
+use crate::{cache::Cache, database::Database, storage::Storage};
 
 pub type State = Arc<AppState>;
 
@@ -12,6 +12,7 @@ pub struct AppState {
     pub config: AppConfig,
     pub database: Database,
     pub storage: Storage,
+    pub cache: Cache,
 }
 
 #[derive(Deserialize, Debug)]
@@ -38,6 +39,13 @@ impl AppState {
 
         let storage = Storage::from_config(&config);
 
-        Ok(Self { config, database, storage })
+        let cache = Cache::new();
+
+        Ok(Self {
+            config,
+            database,
+            storage,
+            cache,
+        })
     }
 }

engine/src/state.rs

@@ -7,7 +7,7 @@ export const queryClient = new QueryClient({
     defaultOptions: {
         queries: {
             gcTime: 1000 * 60 * 60 * 24, // 24 hours
-            staleTime: 1000 * 20, // 20 seconds
+            staleTime: 1000 * 5, // 5 seconds
             retry: 0,
         },
     },