Skip to main content

openauth_core/db/
factory.rs

1mod join_support;
2
3use super::{
4    transform_count_query_with_capabilities, transform_create_query_with_capabilities,
5    transform_delete_many_query_with_capabilities, transform_delete_query_with_capabilities,
6    transform_find_many_query_with_capabilities, transform_find_one_query_with_capabilities,
7    transform_update_many_query_with_capabilities, transform_update_query_with_capabilities,
8    AdapterCapabilities, AdapterFuture, Count, Create, DbAdapter, DbRecord, DbSchema, Delete,
9    DeleteMany, FindMany, FindOne, SchemaCreation, TransactionCallback, Update, UpdateMany,
10};
11use crate::error::OpenAuthError;
12use join_support::{
13    attach_joins, extend_select_for_joins, resolve_fallback_joins, trim_joined_record,
14};
15use std::sync::Arc;
16
17/// Adapter wrapper that maps OpenAuth logical schema names to database names.
18#[derive(Debug, Clone)]
19pub struct SchemaAdapter<A> {
20    schema: DbSchema,
21    inner: A,
22}
23
24impl<A> SchemaAdapter<A> {
25    pub fn new(schema: DbSchema, inner: A) -> Self {
26        Self { schema, inner }
27    }
28
29    pub fn schema(&self) -> &DbSchema {
30        &self.schema
31    }
32
33    pub fn inner(&self) -> &A {
34        &self.inner
35    }
36}
37
38impl<A> DbAdapter for SchemaAdapter<A>
39where
40    A: DbAdapter,
41{
42    fn id(&self) -> &str {
43        self.inner.id()
44    }
45
46    fn capabilities(&self) -> AdapterCapabilities {
47        self.inner.capabilities()
48    }
49
50    fn create<'a>(&'a self, query: Create) -> AdapterFuture<'a, DbRecord> {
51        Box::pin(async move {
52            let capabilities = self.inner.capabilities();
53            let query =
54                transform_create_query_with_capabilities(&self.schema, &capabilities, query)?;
55            self.inner.create(query).await
56        })
57    }
58
59    fn find_one<'a>(&'a self, query: FindOne) -> AdapterFuture<'a, Option<DbRecord>> {
60        Box::pin(async move {
61            let capabilities = self.inner.capabilities();
62            let query =
63                transform_find_one_query_with_capabilities(&self.schema, &capabilities, query)?;
64            self.inner.find_one(query).await
65        })
66    }
67
68    fn find_many<'a>(&'a self, query: FindMany) -> AdapterFuture<'a, Vec<DbRecord>> {
69        Box::pin(async move {
70            let capabilities = self.inner.capabilities();
71            let query =
72                transform_find_many_query_with_capabilities(&self.schema, &capabilities, query)?;
73            self.inner.find_many(query).await
74        })
75    }
76
77    fn count<'a>(&'a self, query: Count) -> AdapterFuture<'a, u64> {
78        Box::pin(async move {
79            let capabilities = self.inner.capabilities();
80            let query =
81                transform_count_query_with_capabilities(&self.schema, &capabilities, query)?;
82            self.inner.count(query).await
83        })
84    }
85
86    fn update<'a>(&'a self, query: Update) -> AdapterFuture<'a, Option<DbRecord>> {
87        Box::pin(async move {
88            let capabilities = self.inner.capabilities();
89            let query =
90                transform_update_query_with_capabilities(&self.schema, &capabilities, query)?;
91            self.inner.update(query).await
92        })
93    }
94
95    fn update_many<'a>(&'a self, query: UpdateMany) -> AdapterFuture<'a, u64> {
96        Box::pin(async move {
97            let capabilities = self.inner.capabilities();
98            let query =
99                transform_update_many_query_with_capabilities(&self.schema, &capabilities, query)?;
100            self.inner.update_many(query).await
101        })
102    }
103
104    fn delete<'a>(&'a self, query: Delete) -> AdapterFuture<'a, ()> {
105        Box::pin(async move {
106            let capabilities = self.inner.capabilities();
107            let query =
108                transform_delete_query_with_capabilities(&self.schema, &capabilities, query)?;
109            self.inner.delete(query).await
110        })
111    }
112
113    fn delete_many<'a>(&'a self, query: DeleteMany) -> AdapterFuture<'a, u64> {
114        Box::pin(async move {
115            let capabilities = self.inner.capabilities();
116            let query =
117                transform_delete_many_query_with_capabilities(&self.schema, &capabilities, query)?;
118            self.inner.delete_many(query).await
119        })
120    }
121
122    fn transaction<'a>(&'a self, callback: TransactionCallback<'a>) -> AdapterFuture<'a, ()> {
123        let schema = self.schema.clone();
124        self.inner.transaction(Box::new(move |transaction| {
125            let adapter = SchemaAdapter::new(schema, transaction);
126            callback(Box::new(adapter))
127        }))
128    }
129
130    fn create_schema<'a>(
131        &'a self,
132        _schema: &'a DbSchema,
133        file: Option<&'a str>,
134    ) -> AdapterFuture<'a, Option<SchemaCreation>> {
135        self.inner.create_schema(&self.schema, file)
136    }
137
138    fn run_migrations<'a>(&'a self, _schema: &'a DbSchema) -> AdapterFuture<'a, ()> {
139        self.inner.run_migrations(&self.schema)
140    }
141}
142
143/// Adapter wrapper that resolves OpenAuth join options at runtime.
144#[derive(Clone)]
145pub struct JoinAdapter<A = Arc<dyn DbAdapter>> {
146    schema: DbSchema,
147    inner: A,
148    experimental_joins: bool,
149}
150
151impl<A> JoinAdapter<A> {
152    pub fn new(schema: DbSchema, inner: A, experimental_joins: bool) -> Self {
153        Self {
154            schema,
155            inner,
156            experimental_joins,
157        }
158    }
159}
160
161impl<A> JoinAdapter<A>
162where
163    A: DbAdapter,
164{
165    fn should_delegate_joins(&self) -> bool {
166        self.experimental_joins && self.inner.capabilities().supports_joins
167    }
168
169    async fn fallback_find_one(
170        &self,
171        mut query: FindOne,
172    ) -> Result<Option<DbRecord>, OpenAuthError> {
173        let joins = resolve_fallback_joins(&self.schema, &query.model, &query.joins, 100)?;
174        let original_select = query.select.clone();
175        extend_select_for_joins(&mut query.select, &joins);
176        query.joins.clear();
177
178        let Some(mut record) = self.inner.find_one(query).await? else {
179            return Ok(None);
180        };
181        attach_joins(&self.inner, &mut [&mut record], &joins).await?;
182        trim_joined_record(&mut record, &original_select, &joins);
183        Ok(Some(record))
184    }
185
186    async fn fallback_find_many(
187        &self,
188        mut query: FindMany,
189    ) -> Result<Vec<DbRecord>, OpenAuthError> {
190        let joins = resolve_fallback_joins(&self.schema, &query.model, &query.joins, 100)?;
191        let original_select = query.select.clone();
192        extend_select_for_joins(&mut query.select, &joins);
193        query.joins.clear();
194
195        let mut records = self.inner.find_many(query).await?;
196        let mut record_refs = records.iter_mut().collect::<Vec<_>>();
197        attach_joins(&self.inner, &mut record_refs, &joins).await?;
198        for record in &mut records {
199            trim_joined_record(record, &original_select, &joins);
200        }
201        Ok(records)
202    }
203}
204
205impl<A> std::fmt::Debug for JoinAdapter<A>
206where
207    A: DbAdapter,
208{
209    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
210        formatter
211            .debug_struct("JoinAdapter")
212            .field("schema", &self.schema)
213            .field("inner", &self.inner.id())
214            .field("experimental_joins", &self.experimental_joins)
215            .finish()
216    }
217}
218
219impl<A> DbAdapter for JoinAdapter<A>
220where
221    A: DbAdapter,
222{
223    fn id(&self) -> &str {
224        self.inner.id()
225    }
226
227    fn capabilities(&self) -> AdapterCapabilities {
228        self.inner.capabilities()
229    }
230
231    fn create<'a>(&'a self, query: Create) -> AdapterFuture<'a, DbRecord> {
232        self.inner.create(query)
233    }
234
235    fn find_one<'a>(&'a self, query: FindOne) -> AdapterFuture<'a, Option<DbRecord>> {
236        Box::pin(async move {
237            if query.joins.is_empty() || self.should_delegate_joins() {
238                self.inner.find_one(query).await
239            } else {
240                self.fallback_find_one(query).await
241            }
242        })
243    }
244
245    fn find_many<'a>(&'a self, query: FindMany) -> AdapterFuture<'a, Vec<DbRecord>> {
246        Box::pin(async move {
247            if query.joins.is_empty() || self.should_delegate_joins() {
248                self.inner.find_many(query).await
249            } else {
250                self.fallback_find_many(query).await
251            }
252        })
253    }
254
255    fn count<'a>(&'a self, query: Count) -> AdapterFuture<'a, u64> {
256        self.inner.count(query)
257    }
258
259    fn update<'a>(&'a self, query: Update) -> AdapterFuture<'a, Option<DbRecord>> {
260        self.inner.update(query)
261    }
262
263    fn update_many<'a>(&'a self, query: UpdateMany) -> AdapterFuture<'a, u64> {
264        self.inner.update_many(query)
265    }
266
267    fn delete<'a>(&'a self, query: Delete) -> AdapterFuture<'a, ()> {
268        self.inner.delete(query)
269    }
270
271    fn delete_many<'a>(&'a self, query: DeleteMany) -> AdapterFuture<'a, u64> {
272        self.inner.delete_many(query)
273    }
274
275    fn transaction<'a>(&'a self, callback: TransactionCallback<'a>) -> AdapterFuture<'a, ()> {
276        let schema = self.schema.clone();
277        let experimental_joins = self.experimental_joins;
278        self.inner.transaction(Box::new(move |transaction| {
279            let adapter = JoinAdapter::new(schema, transaction, experimental_joins);
280            callback(Box::new(adapter))
281        }))
282    }
283
284    fn create_schema<'a>(
285        &'a self,
286        schema: &'a DbSchema,
287        file: Option<&'a str>,
288    ) -> AdapterFuture<'a, Option<SchemaCreation>> {
289        self.inner.create_schema(schema, file)
290    }
291
292    fn run_migrations<'a>(&'a self, schema: &'a DbSchema) -> AdapterFuture<'a, ()> {
293        self.inner.run_migrations(schema)
294    }
295}