cal-redis 0.1.80

Callable Redis Implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// File: cal-redis/src/cache/user.rs

use super::CallableCache;
use crate::{get_user_by_id, get_user_by_ident, get_users};
use cal_core::User;
use redis::RedisError;
use std::sync::Arc;

impl CallableCache {
    /// Retrieves a user by its ID, first checking the local cache and then Redis.
    pub async fn get_user_by_id(&self, id: &str) -> Result<Option<Arc<User>>, RedisError> {
        println!("[CallableCache::get_user_by_id] Getting user by ID: {}", id);
        // Try to get from local cache first
        if let Some(resolved_id) = self.local_cache.user_idents.get(id) {
            println!("[CallableCache::get_user_by_id] Found user ident in local cache: {}", resolved_id);
            if let Some(user) = self.local_cache.users.get(resolved_id.as_str()) {
                println!("[CallableCache::get_user_by_id] Found user in local cache: {}", user.email);
                return Ok(Some(user));
            }

            // If not in local cache, fetch from Redis
            println!("[CallableCache::get_user_by_id] User not in local cache, fetching from Redis");
            match get_user_by_id(self.remote_cache.connection.clone(), &resolved_id).await? {
                Some(user) => {
                    println!("[CallableCache::get_user_by_id] Found user in Redis: {}", user.email);
                    let user_arc = Arc::new(user);
                    self.local_cache
                        .users
                        .insert(resolved_id.to_string(), user_arc.clone());
                    self.local_cache
                        .user_idents
                        .insert(id.to_string(), resolved_id.to_string());
                    Ok(Some(user_arc))
                }
                None => {
                    println!("[CallableCache::get_user_by_id] User not found in Redis");
                    Ok(None)
                }
            }
        } else {
            // Try Redis directly
            println!("[CallableCache::get_user_by_id] User ident not in local cache, checking Redis");
            match get_user_by_ident(self.remote_cache.connection.clone(), id).await? {
                Some(user) => {
                    println!("[CallableCache::get_user_by_id] Found user in Redis by ident: {}", user.email);
                    let user_arc = Arc::new(user);
                    self.local_cache
                        .users
                        .insert(user_arc.id.clone(), user_arc.clone());
                    self.local_cache
                        .user_idents
                        .insert(id.to_string(), user_arc.id.clone());
                    self.local_cache
                        .user_idents
                        .insert(user_arc.email.clone(), user_arc.id.clone());
                    Ok(Some(user_arc))
                }
                None => {
                    println!("[CallableCache::get_user_by_id] User not found in Redis");
                    Ok(None)
                }
            }
        }
    }

    /// Retrieves a user by identifier (email), first checking the local cache and then Redis.
    pub async fn get_user_by_ident(&self, ident: &str) -> Result<Option<Arc<User>>, RedisError> {
        println!("[CallableCache::get_user_by_ident] Getting user by ident: {}", ident);
        self.get_user_by_id(ident).await
    }

    /// Retrieves all users from Redis.
    pub async fn get_users(&self) -> Result<Arc<Vec<User>>, RedisError> {
        println!("[CallableCache::get_users] Getting all users from Redis");
        let users = get_users(self.remote_cache.connection.clone()).await?;
        println!("[CallableCache::get_users] Retrieved {} users from Redis", users.len());
        for user in &users {
            let user_arc = Arc::new(user.clone());
            self.local_cache
                .users
                .insert(user.id.clone(), user_arc.clone());
            self.local_cache
                .user_idents
                .insert(user.id.clone(), user.id.clone());
            self.local_cache
                .user_idents
                .insert(user.email.clone(), user.id.clone());
        }
        Ok(Arc::new(users))
    }
}