Skip to main content

rustauth_redis/
bundle.rs

1use std::sync::Arc;
2
3use rustauth_core::error::RustAuthError;
4use rustauth_core::options::{RateLimitOptions, RustAuthOptions};
5
6use crate::rate_limit::{RedisRateLimitOptions, RedisRateLimitStore};
7use crate::secondary::{RedisSecondaryStorage, RedisSecondaryStorageOptions};
8
9/// Shared connection options for rate limiting and secondary storage.
10#[derive(Debug, Clone, PartialEq, Eq, Default)]
11pub struct RedisOptions {
12    pub rate_limit: RedisRateLimitOptions,
13    pub secondary_storage: RedisSecondaryStorageOptions,
14}
15
16/// Previous name for [`RedisOptions`]; kept for migration.
17pub type RedisRustAuthOptions = RedisOptions;
18
19/// Rate limit and secondary storage backed by one `ConnectionManager`.
20#[derive(Clone)]
21pub struct RedisStores {
22    pub rate_limit: RedisRateLimitStore,
23    pub secondary_storage: RedisSecondaryStorage,
24}
25
26/// Previous name for [`RedisStores`]; kept for migration.
27pub type RedisRustAuthStores = RedisStores;
28
29impl RedisStores {
30    pub async fn connect(url: &str) -> Result<Self, RustAuthError> {
31        Self::connect_with_options(url, RedisOptions::default()).await
32    }
33
34    pub async fn connect_with_options(
35        url: &str,
36        options: RedisOptions,
37    ) -> Result<Self, RustAuthError> {
38        let manager = crate::connect_manager(url).await?;
39        Ok(Self {
40            rate_limit: RedisRateLimitStore::new(manager.clone(), options.rate_limit),
41            secondary_storage: RedisSecondaryStorage::new(manager, options.secondary_storage),
42        })
43    }
44
45    /// Wires both stores into [`RustAuthOptions`] (secondary storage + distributed rate limit).
46    #[must_use]
47    pub fn apply_to_options(&self, options: RustAuthOptions) -> RustAuthOptions {
48        options
49            .secondary_storage(Arc::new(self.secondary_storage.clone()))
50            .rate_limit(RateLimitOptions::secondary_storage(self.rate_limit.clone()))
51    }
52}