Expire calls where one of both parties doesn't talk for 10 minutes.

src/framework/bot.rs

@@ -19,6 +19,7 @@ use crate::{
             components::Component, registry::ComponentRegistry, runner::InteractionRunner,
         },
         runtime::Runtime,
+        tasks::Task,
     },
     utils::Bye,
 };
@@ -92,25 +93,26 @@ where
     }
 }
 
-pub struct Bot<T: Send + Sync, E: Send + Sync = ()> {
+pub struct Bot<S: Send + Sync, E: Send + Sync = ()> {
     shard: ShardId,
-    state: Arc<T>,
+    state: Arc<S>,
     presence: Option<UpdatePresencePayload>,
-    prefixes: Arc<dyn PrefixGetter<T, E> + Send + Sync>,
+    prefixes: Arc<dyn PrefixGetter<S, E> + Send + Sync>,
     intents: Intents,
-    extras: Arc<dyn ExtrasGetter<T, Extras = E>>,
+    extras: Arc<dyn ExtrasGetter<S, Extras = E>>,
     cached_resource_types: Vec<ResourceType>,
-    commands: Vec<Arc<dyn Command<T, E>>>,
-    components: Vec<Arc<dyn Component<T, E>>>,
-    on_ready_handlers: Vec<Arc<dyn OnReadyHandler<T, E>>>,
-    on_reconnect_handlers: Vec<Arc<dyn OnReconnectHandler<T, E>>>,
-    on_interaction_handlers: Vec<Arc<dyn OnInteractionHandler<T, E>>>,
-    on_message_handlers: Vec<Arc<dyn OnMessageHandler<T, E>>>,
-    on_message_edit_handlers: Vec<Arc<dyn OnMessageEditHandler<T, E>>>,
-    on_message_delete_handlers: Vec<Arc<dyn OnMessageDeleteHandler<T, E>>>,
-    on_server_create_handlers: Vec<Arc<dyn OnServerCreateHandler<T, E>>>,
-    on_server_update_handlers: Vec<Arc<dyn OnServerUpdateHandler<T, E>>>,
-    on_server_delete_handlers: Vec<Arc<dyn OnServerDeleteHandler<T, E>>>,
+    commands: Vec<Arc<dyn Command<S, E>>>,
+    components: Vec<Arc<dyn Component<S, E>>>,
+    tasks: Vec<Arc<dyn Task<S, E>>>,
+    on_ready_handlers: Vec<Arc<dyn OnReadyHandler<S, E>>>,
+    on_reconnect_handlers: Vec<Arc<dyn OnReconnectHandler<S, E>>>,
+    on_interaction_handlers: Vec<Arc<dyn OnInteractionHandler<S, E>>>,
+    on_message_handlers: Vec<Arc<dyn OnMessageHandler<S, E>>>,
+    on_message_edit_handlers: Vec<Arc<dyn OnMessageEditHandler<S, E>>>,
+    on_message_delete_handlers: Vec<Arc<dyn OnMessageDeleteHandler<S, E>>>,
+    on_server_create_handlers: Vec<Arc<dyn OnServerCreateHandler<S, E>>>,
+    on_server_update_handlers: Vec<Arc<dyn OnServerUpdateHandler<S, E>>>,
+    on_server_delete_handlers: Vec<Arc<dyn OnServerDeleteHandler<S, E>>>,
 }
 
 impl<T, E> Bot<T, E>
@@ -133,6 +135,7 @@ where
             cached_resource_types: Vec::new(),
             commands: Vec::new(),
             components: Vec::new(),
+            tasks: Vec::new(),
             on_ready_handlers: Vec::new(),
             on_reconnect_handlers: Vec::new(),
             on_interaction_handlers: vec![Arc::new(InteractionRunner)],
@@ -170,6 +173,11 @@ where
         self
     }
 
+    pub fn task(mut self, task: impl Task<T, E> + 'static) -> Self {
+        self.tasks.push(Arc::new(task));
+        self
+    }
+
     pub fn cache_resource_type(mut self, resource_type: ResourceType) -> Self {
         if !self.cached_resource_types.contains(&resource_type) {
             self.cached_resource_types.push(resource_type);
@@ -273,6 +281,23 @@ where
             cache,
         });
 
+        for task in bot.tasks.clone() {
+            let task_rt = runtime.clone();
+
+            tokio::spawn(async move {
+                loop {
+                    task.run(&task_rt)
+                        .await
+                        .inspect_err(|e| {
+                            log::error!("An error occurred while running task {task:?}! {e:?}")
+                        })
+                        .bye();
+
+                    tokio::time::sleep(task.delay()).await;
+                }
+            });
+        }
+
         let mut config = ConfigBuilder::new(token.to_string(), bot.intents);
 
         if let Some(presence) = &bot.presence {

src/framework/mod.rs

@@ -161,3 +161,4 @@ pub mod events;
 pub mod interactions;
 pub mod messages;
 pub mod runtime;
+pub mod tasks;

src/framework/tasks.rs

@@ -0,0 +1,12 @@
+use std::{fmt::Debug, time::Duration};
+
+use async_trait::async_trait;
+
+use crate::framework::runtime::Runtime;
+
+#[async_trait]
+pub trait Task<S, E>: Send + Sync + Debug {
+    fn delay(&self) -> Duration;
+
+    async fn run(&self, rt: &Runtime<S, E>) -> anyhow::Result<()>;
+}