Skip to main content

openauth_core/db/
hooks.rs

1//! Database adapter wrapper that executes plugin hooks around mutations.
2
3mod pipeline;
4
5use std::sync::Arc;
6
7use super::{
8    AdapterCapabilities, AdapterFuture, Count, Create, DbAdapter, DbRecord, Delete, DeleteMany,
9    FindMany, FindOne, SchemaCreation, TransactionCallback, Update, UpdateMany,
10};
11use crate::db::DbSchema;
12use crate::plugin::PluginDatabaseHook;
13use pipeline::{
14    hooked_create, hooked_delete, hooked_delete_many, hooked_update, hooked_update_many,
15    AfterHookQueue,
16};
17
18/// Adapter wrapper that runs plugin database hooks for mutating operations.
19#[derive(Clone)]
20pub struct HookedAdapter<A = Arc<dyn DbAdapter>> {
21    inner: A,
22    hooks: Arc<Vec<PluginDatabaseHook>>,
23    after_queue: Option<AfterHookQueue>,
24}
25
26impl<A> HookedAdapter<A> {
27    pub fn new(inner: A, hooks: Vec<PluginDatabaseHook>) -> Self {
28        Self {
29            inner,
30            hooks: Arc::new(hooks),
31            after_queue: None,
32        }
33    }
34
35    pub fn hooks(&self) -> &[PluginDatabaseHook] {
36        self.hooks.as_slice()
37    }
38
39    fn with_after_queue(
40        inner: A,
41        hooks: Arc<Vec<PluginDatabaseHook>>,
42        after_queue: AfterHookQueue,
43    ) -> Self {
44        Self {
45            inner,
46            hooks,
47            after_queue: Some(after_queue),
48        }
49    }
50}
51
52impl<A> DbAdapter for HookedAdapter<A>
53where
54    A: DbAdapter,
55{
56    fn id(&self) -> &str {
57        self.inner.id()
58    }
59
60    fn capabilities(&self) -> AdapterCapabilities {
61        self.inner.capabilities()
62    }
63
64    fn create<'a>(&'a self, query: Create) -> AdapterFuture<'a, DbRecord> {
65        hooked_create(
66            &self.inner,
67            Arc::clone(&self.hooks),
68            self.after_queue.clone(),
69            query,
70        )
71    }
72
73    fn find_one<'a>(&'a self, query: FindOne) -> AdapterFuture<'a, Option<DbRecord>> {
74        self.inner.find_one(query)
75    }
76
77    fn find_many<'a>(&'a self, query: FindMany) -> AdapterFuture<'a, Vec<DbRecord>> {
78        self.inner.find_many(query)
79    }
80
81    fn count<'a>(&'a self, query: Count) -> AdapterFuture<'a, u64> {
82        self.inner.count(query)
83    }
84
85    fn update<'a>(&'a self, query: Update) -> AdapterFuture<'a, Option<DbRecord>> {
86        hooked_update(
87            &self.inner,
88            Arc::clone(&self.hooks),
89            self.after_queue.clone(),
90            query,
91        )
92    }
93
94    fn update_many<'a>(&'a self, query: UpdateMany) -> AdapterFuture<'a, u64> {
95        hooked_update_many(
96            &self.inner,
97            Arc::clone(&self.hooks),
98            self.after_queue.clone(),
99            query,
100        )
101    }
102
103    fn delete<'a>(&'a self, query: Delete) -> AdapterFuture<'a, ()> {
104        hooked_delete(
105            &self.inner,
106            Arc::clone(&self.hooks),
107            self.after_queue.clone(),
108            query,
109        )
110    }
111
112    fn delete_many<'a>(&'a self, query: DeleteMany) -> AdapterFuture<'a, u64> {
113        hooked_delete_many(
114            &self.inner,
115            Arc::clone(&self.hooks),
116            self.after_queue.clone(),
117            query,
118        )
119    }
120
121    fn transaction<'a>(&'a self, callback: TransactionCallback<'a>) -> AdapterFuture<'a, ()> {
122        Box::pin(async move {
123            let should_run_after_hooks = self.after_queue.is_none();
124            let after_queue = self.after_queue.clone().unwrap_or_default();
125            let transaction_queue = after_queue.clone();
126            let hooks = Arc::clone(&self.hooks);
127            self.inner
128                .transaction(Box::new(move |transaction| {
129                    let adapter = HookedAdapter::with_after_queue(
130                        transaction,
131                        Arc::clone(&hooks),
132                        transaction_queue,
133                    );
134                    callback(Box::new(adapter))
135                }))
136                .await?;
137            if should_run_after_hooks {
138                after_queue.run(self.hooks.as_slice(), &self.inner).await?;
139            }
140            Ok(())
141        })
142    }
143
144    fn create_schema<'a>(
145        &'a self,
146        schema: &'a DbSchema,
147        file: Option<&'a str>,
148    ) -> AdapterFuture<'a, Option<SchemaCreation>> {
149        self.inner.create_schema(schema, file)
150    }
151
152    fn run_migrations<'a>(&'a self, schema: &'a DbSchema) -> AdapterFuture<'a, ()> {
153        self.inner.run_migrations(schema)
154    }
155}