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#[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#[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}