Struct Cache 

pub struct Cache;

Cache facade - main entry point for cache operations

Provides static methods for accessing the cache. The cache store is automatically initialized when the server starts.

Example

use kit::Cache;
use std::time::Duration;

// Store with TTL
Cache::put("key", &value, Some(Duration::from_secs(3600))).await?;

// Store forever (no expiration)
Cache::forever("key", &value).await?;

// Retrieve
let value: Option<MyType> = Cache::get("key").await?;

// Get or compute (remember pattern)
let value = Cache::remember("key", Some(Duration::from_secs(3600)), || async {
    expensive_computation().await
}).await?;

Implementations

impl Cache

pub fn store() -> Result<Arc<dyn CacheStore>, FrameworkError>

Get the underlying cache store

pub fn is_initialized() -> bool

Check if the cache is initialized

pub async fn get<T: DeserializeOwned>( key: &str, ) -> Result<Option<T>, FrameworkError>

Retrieve an item from the cache

Returns None if the key doesn’t exist or has expired.

Example

let user: Option<User> = Cache::get("user:1").await?;

pub async fn put<T: Serialize>( key: &str, value: &T, ttl: Option<Duration>, ) -> Result<(), FrameworkError>

Store an item in the cache

If ttl is None, uses the default TTL from config (or no expiration if 0).

Example

Cache::put("user:1", &user, Some(Duration::from_secs(3600))).await?;

pub async fn forever<T: Serialize>( key: &str, value: &T, ) -> Result<(), FrameworkError>

Store an item forever (no expiration)

Example

Cache::forever("config:settings", &settings).await?;

pub async fn has(key: &str) -> Result<bool, FrameworkError>

Check if a key exists in the cache

Example

if Cache::has("user:1").await? {
    println!("User is cached");
}

pub async fn forget(key: &str) -> Result<bool, FrameworkError>

Remove an item from the cache

Returns true if the item existed and was removed.

Example

Cache::forget("user:1").await?;

pub async fn flush() -> Result<(), FrameworkError>

Remove all items from the cache

Example

Cache::flush().await?;

pub async fn increment(key: &str, amount: i64) -> Result<i64, FrameworkError>

Increment a numeric value

If the key doesn’t exist, it’s initialized to 0 before incrementing. Returns the new value.

Example

let count = Cache::increment("visits", 1).await?;

pub async fn decrement(key: &str, amount: i64) -> Result<i64, FrameworkError>

Decrement a numeric value

If the key doesn’t exist, it’s initialized to 0 before decrementing. Returns the new value.

Example

let remaining = Cache::decrement("quota", 1).await?;

pub async fn remember<T, F, Fut>( key: &str, ttl: Option<Duration>, default: F, ) -> Result<T, FrameworkError>

where T: Serialize + DeserializeOwned, F: FnOnce() -> Fut, Fut: Future<Output = Result<T, FrameworkError>>,

Get an item or store a default value if it doesn’t exist

If the key exists, returns the cached value. If not, calls the closure to compute the value, stores it, and returns it.

Example

let user = Cache::remember("user:1", Some(Duration::from_secs(3600)), || async {
    User::find(1).await
}).await?;

pub async fn remember_forever<T, F, Fut>( key: &str, default: F, ) -> Result<T, FrameworkError>

where T: Serialize + DeserializeOwned, F: FnOnce() -> Fut, Fut: Future<Output = Result<T, FrameworkError>>,

Get an item or store a default value forever

Same as remember but with no expiration.