feature: jetstream purge and set

Cargo.lock

···
 ]
 
 [[package]]
+name = "atproto-jetstream"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e55d1140fcf5c6be0c03e7db773c6a9258986340118015d9bb536bf22689de2"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "atproto-identity",
+ "futures",
+ "http",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.16",
+ "tokio",
+ "tokio-util",
+ "tokio-websockets",
+ "tracing",
+ "tracing-subscriber",
+ "urlencoding",
+ "zstd",
+]
+
+[[package]]
 name = "autocfg"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "5252b3d2648e5eedbc1a6f501e3c795e07025c1e93bbf8bbdd6eef7f447a6d54"
 dependencies = [
  "find-msvc-tools",
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
···
 ]
 
 [[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
 name = "futures-channel"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
+ "futures-channel",
  "futures-core",
  "futures-io",
  "futures-macro",
···
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.3",
+ "libc",
+]
+
+[[package]]
 name = "js-sys"
 version = "0.3.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "anyhow",
  "async-trait",
  "atproto-identity",
+ "atproto-jetstream",
  "axum",
  "bincode",
  "cadence",
···
  "digest",
  "rand_core 0.6.4",
 ]
+
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
 name = "slab"
···
  "io-uring",
  "libc",
  "mio",
+ "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
  "slab",
···
  "futures-util",
  "pin-project-lite",
  "tokio",
+]
+
+[[package]]
+name = "tokio-websockets"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fcaf159b4e7a376b05b5bfd77bfd38f3324f5fce751b4213bfc7eaa47affb4e"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "httparse",
+ "rand 0.9.2",
+ "ring",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "simdutf8",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
 ]
 
 [[package]]
···
  "percent-encoding",
  "serde",
 ]
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
 
 [[package]]
 name = "utf8_iter"
···
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]

Cargo.toml

···
 anyhow = "1.0"
 async-trait = "0.1"
 atproto-identity = { version = "0.11.3" }
+atproto-jetstream = { version = "0.11.3" }
 axum = { version = "0.8" }
 bincode = { version = "2.0.1", features = ["serde"] }
 cadence = "1.6.0"

src/bin/quickdid.rs

···
     config::{CertificateBundles, DnsNameservers},
     resolve::HickoryDnsResolver,
 };
+use atproto_jetstream::{Consumer as JetstreamConsumer, ConsumerTaskConfig};
 use quickdid::{
     cache::create_redis_pool,
     config::Config,
···
     },
     handle_resolver_task::{HandleResolverTaskConfig, create_handle_resolver_task_with_config},
     http::{AppContext, create_router},
+    jetstream_handler::QuickDidEventHandler,
     metrics::create_metrics_publisher,
     queue::{
         HandleResolutionWork, QueueAdapter, create_mpsc_queue_from_channel, create_noop_queue,
···
                 );
                 println!(
                     "    PROACTIVE_REFRESH_THRESHOLD Threshold as percentage of TTL (0.0-1.0, default: 0.8)"
+                );
+                println!();
+                println!("    JETSTREAM:");
+                println!(
+                    "    JETSTREAM_ENABLED       Enable Jetstream consumer (default: false)"
+                );
+                println!(
+                    "    JETSTREAM_HOSTNAME      Jetstream hostname (default: jetstream.atproto.tools)"
                 );
                 println!();
                 println!(
···
     let app_context = AppContext::new(
         handle_resolver.clone(),
         handle_queue,
-        metrics_publisher,
+        metrics_publisher.clone(),
         config.etag_seed.clone(),
         config.cache_control_header.clone(),
         config.static_files_dir.clone(),
···
             signal_token.cancel();
             tracing::info!("Signal handler task completed");
         });
+    }
+
+    // Start Jetstream consumer if enabled
+    if config.jetstream_enabled {
+        let jetstream_resolver = handle_resolver.clone();
+        let jetstream_metrics = metrics_publisher.clone();
+        let jetstream_hostname = config.jetstream_hostname.clone();
+        let jetstream_user_agent = config.user_agent.clone();
+
+        spawn_cancellable_task(
+            &tracker,
+            token.clone(),
+            "jetstream_consumer",
+            move |cancel_token| async move {
+                tracing::info!(hostname = %jetstream_hostname, "Starting Jetstream consumer");
+
+                // Create event handler
+                let event_handler = Arc::new(QuickDidEventHandler::new(
+                    jetstream_resolver,
+                    jetstream_metrics.clone(),
+                ));
+
+                // Reconnection loop
+                let mut reconnect_count = 0u32;
+                let max_reconnects_per_minute = 5;
+                let reconnect_window = std::time::Duration::from_secs(60);
+                let mut last_disconnect = std::time::Instant::now() - reconnect_window;
+
+                while !cancel_token.is_cancelled() {
+                    let now = std::time::Instant::now();
+                    if now.duration_since(last_disconnect) < reconnect_window {
+                        reconnect_count += 1;
+                        if reconnect_count > max_reconnects_per_minute {
+                            tracing::warn!(
+                                count = reconnect_count,
+                                "Too many Jetstream reconnects, waiting 60 seconds"
+                            );
+                            tokio::time::sleep(reconnect_window).await;
+                            reconnect_count = 0;
+                            last_disconnect = now;
+                            continue;
+                        }
+                    } else {
+                        reconnect_count = 0;
+                    }
+
+                    // Create consumer configuration
+                    let consumer_config = ConsumerTaskConfig {
+                        user_agent: jetstream_user_agent.clone(),
+                        compression: false,
+                        zstd_dictionary_location: String::new(),
+                        jetstream_hostname: jetstream_hostname.clone(),
+                        collections: vec![],  // Listen to all collections
+                        dids: vec![],
+                        max_message_size_bytes: None,
+                        cursor: None,
+                        require_hello: true,
+                    };
+
+                    let consumer = JetstreamConsumer::new(consumer_config);
+
+                    // Register event handler
+                    if let Err(e) = consumer.register_handler(event_handler.clone()).await {
+                        tracing::error!(error = ?e, "Failed to register Jetstream event handler");
+                        continue;
+                    }
+
+                    // Run consumer with cancellation support
+                    match consumer.run_background(cancel_token.clone()).await {
+                        Ok(()) => {
+                            tracing::info!("Jetstream consumer stopped normally");
+                            if cancel_token.is_cancelled() {
+                                break;
+                            }
+                            last_disconnect = std::time::Instant::now();
+                            tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+                        }
+                        Err(e) => {
+                            tracing::error!(error = ?e, "Jetstream consumer connection failed, will reconnect");
+                            jetstream_metrics.incr("jetstream.connection.error").await;
+                            last_disconnect = std::time::Instant::now();
+
+                            if !cancel_token.is_cancelled() {
+                                tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+                            }
+                        }
+                    }
+                }
+
+                tracing::info!("Jetstream consumer task shutting down");
+                Ok(())
+            },
+        );
+    } else {
+        tracing::info!("Jetstream consumer disabled");
     }
 
     // Start HTTP server with cancellation support

src/config.rs

···
     /// When set, the root handler will serve files from this directory.
     /// Default: "www" (relative to working directory)
     pub static_files_dir: String,
+
+    /// Enable Jetstream consumer for AT Protocol events.
+    /// When enabled, the service will consume Account and Identity events
+    /// to maintain cache consistency.
+    /// Default: false
+    pub jetstream_enabled: bool,
+
+    /// Jetstream WebSocket hostname for consuming AT Protocol events.
+    /// Example: "jetstream.atproto.tools" or "jetstream1.us-west.bsky.network"
+    /// Default: "jetstream.atproto.tools"
+    pub jetstream_hostname: String,
 }
 
 impl Config {
···
             proactive_refresh_enabled: parse_env("PROACTIVE_REFRESH_ENABLED", false)?,
             proactive_refresh_threshold: parse_env("PROACTIVE_REFRESH_THRESHOLD", 0.8)?,
             static_files_dir: get_env_or_default("STATIC_FILES_DIR", Some("www")).unwrap(),
+            jetstream_enabled: parse_env("JETSTREAM_ENABLED", false)?,
+            jetstream_hostname: get_env_or_default("JETSTREAM_HOSTNAME", Some("jetstream.atproto.tools")).unwrap(),
         };
 
         // Calculate the Cache-Control header value if enabled

src/jetstream_handler.rs

···
+//! Jetstream event handler for QuickDID
+//!
+//! This module provides the event handler for processing AT Protocol Jetstream events,
+//! specifically handling Account and Identity events to maintain cache consistency.
+
+use crate::handle_resolver::HandleResolver;
+use crate::metrics::MetricsPublisher;
+use anyhow::Result;
+use atproto_jetstream::{EventHandler, JetstreamEvent};
+use std::sync::Arc;
+use tracing::{debug, info, warn};
+
+/// Jetstream event handler for QuickDID
+///
+/// This handler processes AT Protocol events from the Jetstream firehose to keep
+/// the handle resolver cache in sync with the network state.
+///
+/// # Event Processing
+///
+/// ## Account Events
+/// - When an account is marked as "deleted" or "deactivated", the DID is purged from the cache
+/// - Metrics are tracked for successful and failed purge operations
+///
+/// ## Identity Events
+/// - When an identity event contains a handle, the handle-to-DID mapping is updated
+/// - When an identity event lacks a handle (indicating removal), the DID is purged
+/// - Metrics are tracked for successful and failed update/purge operations
+///
+/// # Example
+///
+/// ```no_run
+/// use quickdid::jetstream_handler::QuickDidEventHandler;
+/// use quickdid::handle_resolver::HandleResolver;
+/// use quickdid::metrics::MetricsPublisher;
+/// use std::sync::Arc;
+///
+/// # async fn example(resolver: Arc<dyn HandleResolver>, metrics: Arc<dyn MetricsPublisher>) {
+/// let handler = QuickDidEventHandler::new(resolver, metrics);
+/// // Register with a JetstreamConsumer
+/// # }
+/// ```
+pub struct QuickDidEventHandler {
+    resolver: Arc<dyn HandleResolver>,
+    metrics: Arc<dyn MetricsPublisher>,
+}
+
+impl QuickDidEventHandler {
+    /// Create a new Jetstream event handler
+    ///
+    /// # Arguments
+    ///
+    /// * `resolver` - The handle resolver to use for cache operations
+    /// * `metrics` - The metrics publisher for tracking event processing
+    pub fn new(resolver: Arc<dyn HandleResolver>, metrics: Arc<dyn MetricsPublisher>) -> Self {
+        Self { resolver, metrics }
+    }
+}
+
+#[async_trait::async_trait]
+impl EventHandler for QuickDidEventHandler {
+    fn handler_id(&self) -> String {
+        "quickdid_handler".to_string()
+    }
+
+    async fn handle_event(&self, event: JetstreamEvent) -> Result<()> {
+        match event {
+            JetstreamEvent::Account { did, kind, .. } => {
+                // If account kind is "deleted" or "deactivated", purge the DID
+                if kind == "deleted" || kind == "deactivated" {
+                    info!(did = %did, kind = %kind, "Purging account");
+                    match self.resolver.purge(&did).await {
+                        Ok(()) => {
+                            self.metrics.incr("jetstream.account.purged").await;
+                        }
+                        Err(e) => {
+                            warn!(did = %did, error = ?e, "Failed to purge DID");
+                            self.metrics.incr("jetstream.account.purge_error").await;
+                        }
+                    }
+                }
+                self.metrics.incr("jetstream.account.processed").await;
+            }
+            JetstreamEvent::Identity { did, identity, .. } => {
+                // Extract handle from identity JSON if available
+                if !identity.is_null() {
+                    if let Some(handle_value) = identity.get("handle") {
+                        if let Some(handle) = handle_value.as_str() {
+                            info!(handle = %handle, did = %did, "Updating identity mapping");
+                            match self.resolver.set(handle, &did).await {
+                                Ok(()) => {
+                                    self.metrics.incr("jetstream.identity.updated").await;
+                                }
+                                Err(e) => {
+                                    warn!(handle = %handle, did = %did, error = ?e, "Failed to update mapping");
+                                    self.metrics.incr("jetstream.identity.update_error").await;
+                                }
+                            }
+                        } else {
+                            // No handle or invalid handle, purge the DID
+                            info!(did = %did, "Purging identity without valid handle");
+                            match self.resolver.purge(&did).await {
+                                Ok(()) => {
+                                    self.metrics.incr("jetstream.identity.purged").await;
+                                }
+                                Err(e) => {
+                                    warn!(did = %did, error = ?e, "Failed to purge DID");
+                                    self.metrics.incr("jetstream.identity.purge_error").await;
+                                }
+                            }
+                        }
+                    } else {
+                        // No handle field, purge the DID
+                        info!(did = %did, "Purging identity without handle field");
+                        match self.resolver.purge(&did).await {
+                            Ok(()) => {
+                                self.metrics.incr("jetstream.identity.purged").await;
+                            }
+                            Err(e) => {
+                                warn!(did = %did, error = ?e, "Failed to purge DID");
+                                self.metrics.incr("jetstream.identity.purge_error").await;
+                            }
+                        }
+                    }
+                } else {
+                    // Null identity means removed, purge the DID
+                    info!(did = %did, "Purging identity with null info");
+                    match self.resolver.purge(&did).await {
+                        Ok(()) => {
+                            self.metrics.incr("jetstream.identity.purged").await;
+                        }
+                        Err(e) => {
+                            warn!(did = %did, error = ?e, "Failed to purge DID");
+                            self.metrics.incr("jetstream.identity.purge_error").await;
+                        }
+                    }
+                }
+                self.metrics.incr("jetstream.identity.processed").await;
+            }
+            _ => {
+                // Other event types we don't care about
+                debug!("Ignoring unhandled Jetstream event type");
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::handle_resolver::HandleResolverError;
+    use crate::metrics::NoOpMetricsPublisher;
+    use async_trait::async_trait;
+    use serde_json::json;
+
+    /// Mock resolver for testing
+    struct MockResolver {
+        purge_called: std::sync::Arc<std::sync::Mutex<Vec<String>>>,
+        set_called: std::sync::Arc<std::sync::Mutex<Vec<(String, String)>>>,
+    }
+
+    impl MockResolver {
+        fn new() -> Self {
+            Self {
+                purge_called: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
+                set_called: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
+            }
+        }
+
+        fn get_purge_calls(&self) -> Vec<String> {
+            self.purge_called.lock().unwrap().clone()
+        }
+
+        fn get_set_calls(&self) -> Vec<(String, String)> {
+            self.set_called.lock().unwrap().clone()
+        }
+    }
+
+    #[async_trait]
+    impl HandleResolver for MockResolver {
+        async fn resolve(&self, _handle: &str) -> Result<(String, u64), HandleResolverError> {
+            unimplemented!("Not needed for tests")
+        }
+
+        async fn purge(&self, subject: &str) -> Result<(), HandleResolverError> {
+            self.purge_called.lock().unwrap().push(subject.to_string());
+            Ok(())
+        }
+
+        async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
+            self.set_called
+                .lock()
+                .unwrap()
+                .push((handle.to_string(), did.to_string()));
+            Ok(())
+        }
+    }
+
+    #[tokio::test]
+    async fn test_account_deleted_event() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver.clone(), metrics);
+
+        // Create a deleted account event
+        let event = JetstreamEvent::Account {
+            did: "did:plc:test123".to_string(),
+            kind: "deleted".to_string(),
+            time_us: 0,
+            identity: json!(null),
+        };
+
+        handler.handle_event(event).await.unwrap();
+
+        // Verify the DID was purged
+        let purge_calls = resolver.get_purge_calls();
+        assert_eq!(purge_calls.len(), 1);
+        assert_eq!(purge_calls[0], "did:plc:test123");
+    }
+
+    #[tokio::test]
+    async fn test_account_deactivated_event() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver.clone(), metrics);
+
+        // Create a deactivated account event
+        let event = JetstreamEvent::Account {
+            did: "did:plc:test456".to_string(),
+            kind: "deactivated".to_string(),
+            time_us: 0,
+            identity: json!(null),
+        };
+
+        handler.handle_event(event).await.unwrap();
+
+        // Verify the DID was purged
+        let purge_calls = resolver.get_purge_calls();
+        assert_eq!(purge_calls.len(), 1);
+        assert_eq!(purge_calls[0], "did:plc:test456");
+    }
+
+    #[tokio::test]
+    async fn test_account_active_event() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver.clone(), metrics);
+
+        // Create an active account event (should not purge)
+        let event = JetstreamEvent::Account {
+            did: "did:plc:test789".to_string(),
+            kind: "active".to_string(),
+            time_us: 0,
+            identity: json!(null),
+        };
+
+        handler.handle_event(event).await.unwrap();
+
+        // Verify the DID was NOT purged
+        let purge_calls = resolver.get_purge_calls();
+        assert_eq!(purge_calls.len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_identity_with_handle_event() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver.clone(), metrics);
+
+        // Create an identity event with a handle
+        let event = JetstreamEvent::Identity {
+            did: "did:plc:testuser".to_string(),
+            kind: "update".to_string(),
+            time_us: 0,
+            identity: json!({
+                "handle": "alice.bsky.social"
+            }),
+        };
+
+        handler.handle_event(event).await.unwrap();
+
+        // Verify the set method was called
+        let set_calls = resolver.get_set_calls();
+        assert_eq!(set_calls.len(), 1);
+        assert_eq!(set_calls[0], ("alice.bsky.social".to_string(), "did:plc:testuser".to_string()));
+
+        // Verify no purge was called
+        let purge_calls = resolver.get_purge_calls();
+        assert_eq!(purge_calls.len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_identity_without_handle_event() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver.clone(), metrics);
+
+        // Create an identity event without a handle field
+        let event = JetstreamEvent::Identity {
+            did: "did:plc:nohandle".to_string(),
+            kind: "update".to_string(),
+            time_us: 0,
+            identity: json!({
+                "other_field": "value"
+            }),
+        };
+
+        handler.handle_event(event).await.unwrap();
+
+        // Verify the DID was purged
+        let purge_calls = resolver.get_purge_calls();
+        assert_eq!(purge_calls.len(), 1);
+        assert_eq!(purge_calls[0], "did:plc:nohandle");
+
+        // Verify set was not called
+        let set_calls = resolver.get_set_calls();
+        assert_eq!(set_calls.len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_identity_with_null_identity() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver.clone(), metrics);
+
+        // Create an identity event with null identity
+        let event = JetstreamEvent::Identity {
+            did: "did:plc:nullidentity".to_string(),
+            kind: "delete".to_string(),
+            time_us: 0,
+            identity: json!(null),
+        };
+
+        handler.handle_event(event).await.unwrap();
+
+        // Verify the DID was purged
+        let purge_calls = resolver.get_purge_calls();
+        assert_eq!(purge_calls.len(), 1);
+        assert_eq!(purge_calls[0], "did:plc:nullidentity");
+
+        // Verify set was not called
+        let set_calls = resolver.get_set_calls();
+        assert_eq!(set_calls.len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_handler_id() {
+        let resolver = Arc::new(MockResolver::new());
+        let metrics = Arc::new(NoOpMetricsPublisher::new());
+        let handler = QuickDidEventHandler::new(resolver, metrics);
+
+        assert_eq!(handler.handler_id(), "quickdid_handler");
+    }
+}

src/lib.rs

···
 pub mod config; // Config and Args needed by binary
 pub mod handle_resolver; // Only traits and factory functions exposed
 pub mod http; // Only create_router exposed
+pub mod jetstream_handler; // Jetstream event handler for AT Protocol events
 
 // Semi-public modules - needed by binary but with limited exposure
 pub mod cache; // Only create_redis_pool exposed