1use crate::internal::auth::session::{AsyncSessionProvider, SessionProvider};
2use crate::internal::transport::{AsyncAuthenticatedRpcTransport, AuthenticatedRpcTransport};
3
4pub struct SiteService<'a> {
5 client: &'a crate::core::ImClient,
6}
7
8impl<'a> SiteService<'a> {
9 pub(crate) fn new(client: &'a crate::core::ImClient) -> Self {
10 Self { client }
11 }
12
13 pub fn get_root(&self, domain: super::SiteDomain) -> crate::ImResult<super::SiteRootDocument> {
14 SiteRuntime::new(
15 crate::internal::auth::session::FileSessionProvider::new(self.client),
16 crate::internal::transport::CoreHttpTransport::new(self.client),
17 )
18 .get_root(domain)
19 }
20
21 pub async fn get_root_async(
22 &self,
23 domain: super::SiteDomain,
24 ) -> crate::ImResult<super::SiteRootDocument> {
25 SiteRuntime::new(
26 crate::internal::auth::session::FileSessionProvider::new(self.client),
27 crate::internal::transport::CoreHttpTransport::new(self.client),
28 )
29 .get_root_async(domain)
30 .await
31 }
32
33 pub fn set_root(
34 &self,
35 draft: super::SiteRootDraft,
36 ) -> crate::ImResult<super::SiteRootDocument> {
37 SiteRuntime::new(
38 crate::internal::auth::session::FileSessionProvider::new(self.client),
39 crate::internal::transport::CoreHttpTransport::new(self.client),
40 )
41 .set_root(draft)
42 }
43
44 pub async fn set_root_async(
45 &self,
46 draft: super::SiteRootDraft,
47 ) -> crate::ImResult<super::SiteRootDocument> {
48 SiteRuntime::new(
49 crate::internal::auth::session::FileSessionProvider::new(self.client),
50 crate::internal::transport::CoreHttpTransport::new(self.client),
51 )
52 .set_root_async(draft)
53 .await
54 }
55
56 pub fn list_pages(
57 &self,
58 query: super::SitePageQuery,
59 ) -> crate::ImResult<crate::ids::Page<super::SitePageDocument>> {
60 SiteRuntime::new(
61 crate::internal::auth::session::FileSessionProvider::new(self.client),
62 crate::internal::transport::CoreHttpTransport::new(self.client),
63 )
64 .list_pages(query)
65 }
66
67 pub async fn list_pages_async(
68 &self,
69 query: super::SitePageQuery,
70 ) -> crate::ImResult<crate::ids::Page<super::SitePageDocument>> {
71 SiteRuntime::new(
72 crate::internal::auth::session::FileSessionProvider::new(self.client),
73 crate::internal::transport::CoreHttpTransport::new(self.client),
74 )
75 .list_pages_async(query)
76 .await
77 }
78
79 pub fn get_page(&self, page: super::SitePageRef) -> crate::ImResult<super::SitePageDocument> {
80 SiteRuntime::new(
81 crate::internal::auth::session::FileSessionProvider::new(self.client),
82 crate::internal::transport::CoreHttpTransport::new(self.client),
83 )
84 .get_page(page)
85 }
86
87 pub async fn get_page_async(
88 &self,
89 page: super::SitePageRef,
90 ) -> crate::ImResult<super::SitePageDocument> {
91 SiteRuntime::new(
92 crate::internal::auth::session::FileSessionProvider::new(self.client),
93 crate::internal::transport::CoreHttpTransport::new(self.client),
94 )
95 .get_page_async(page)
96 .await
97 }
98
99 pub fn create_page(
100 &self,
101 draft: super::SitePageDraft,
102 ) -> crate::ImResult<super::SitePageDocument> {
103 SiteRuntime::new(
104 crate::internal::auth::session::FileSessionProvider::new(self.client),
105 crate::internal::transport::CoreHttpTransport::new(self.client),
106 )
107 .create_page(draft)
108 }
109
110 pub async fn create_page_async(
111 &self,
112 draft: super::SitePageDraft,
113 ) -> crate::ImResult<super::SitePageDocument> {
114 SiteRuntime::new(
115 crate::internal::auth::session::FileSessionProvider::new(self.client),
116 crate::internal::transport::CoreHttpTransport::new(self.client),
117 )
118 .create_page_async(draft)
119 .await
120 }
121
122 pub fn update_page(
123 &self,
124 page: super::SitePageRef,
125 patch: super::SitePageUpdate,
126 ) -> crate::ImResult<super::SitePageDocument> {
127 SiteRuntime::new(
128 crate::internal::auth::session::FileSessionProvider::new(self.client),
129 crate::internal::transport::CoreHttpTransport::new(self.client),
130 )
131 .update_page(page, patch)
132 }
133
134 pub async fn update_page_async(
135 &self,
136 page: super::SitePageRef,
137 patch: super::SitePageUpdate,
138 ) -> crate::ImResult<super::SitePageDocument> {
139 SiteRuntime::new(
140 crate::internal::auth::session::FileSessionProvider::new(self.client),
141 crate::internal::transport::CoreHttpTransport::new(self.client),
142 )
143 .update_page_async(page, patch)
144 .await
145 }
146
147 pub fn rename_page(
148 &self,
149 page: super::SitePageRef,
150 target: crate::content::PageSlug,
151 ) -> crate::ImResult<super::SitePageDocument> {
152 SiteRuntime::new(
153 crate::internal::auth::session::FileSessionProvider::new(self.client),
154 crate::internal::transport::CoreHttpTransport::new(self.client),
155 )
156 .rename_page(page, target)
157 }
158
159 pub async fn rename_page_async(
160 &self,
161 page: super::SitePageRef,
162 target: crate::content::PageSlug,
163 ) -> crate::ImResult<super::SitePageDocument> {
164 SiteRuntime::new(
165 crate::internal::auth::session::FileSessionProvider::new(self.client),
166 crate::internal::transport::CoreHttpTransport::new(self.client),
167 )
168 .rename_page_async(page, target)
169 .await
170 }
171
172 pub fn delete_page(
173 &self,
174 page: super::SitePageRef,
175 ) -> crate::ImResult<crate::content::PageDeleteResult> {
176 SiteRuntime::new(
177 crate::internal::auth::session::FileSessionProvider::new(self.client),
178 crate::internal::transport::CoreHttpTransport::new(self.client),
179 )
180 .delete_page(page)
181 }
182
183 pub async fn delete_page_async(
184 &self,
185 page: super::SitePageRef,
186 ) -> crate::ImResult<crate::content::PageDeleteResult> {
187 SiteRuntime::new(
188 crate::internal::auth::session::FileSessionProvider::new(self.client),
189 crate::internal::transport::CoreHttpTransport::new(self.client),
190 )
191 .delete_page_async(page)
192 .await
193 }
194}
195
196pub(crate) struct SiteRuntime<P, T> {
197 session_provider: P,
198 transport: T,
199}
200
201impl<P, T> SiteRuntime<P, T> {
202 pub(crate) fn new(session_provider: P, transport: T) -> Self {
203 Self {
204 session_provider,
205 transport,
206 }
207 }
208}
209
210impl<P, T> SiteRuntime<P, T>
211where
212 P: SessionProvider,
213 T: AuthenticatedRpcTransport,
214{
215 pub(crate) fn get_root(
216 mut self,
217 domain: super::SiteDomain,
218 ) -> crate::ImResult<super::SiteRootDocument> {
219 self.ensure_session()?;
220 let fallback_domain = domain.clone();
221 let call = super::wire::build_get_root_rpc_call(domain);
222 let raw = self.call(call)?;
223 super::wire::normalize_root(raw, &fallback_domain)
224 }
225
226 pub(crate) fn set_root(
227 mut self,
228 draft: super::SiteRootDraft,
229 ) -> crate::ImResult<super::SiteRootDocument> {
230 self.ensure_session()?;
231 let fallback_domain = draft.domain.clone();
232 let call = super::wire::build_set_root_rpc_call(draft);
233 let raw = self.call(call)?;
234 super::wire::normalize_root(raw, &fallback_domain)
235 }
236
237 pub(crate) fn list_pages(
238 mut self,
239 query: super::SitePageQuery,
240 ) -> crate::ImResult<crate::ids::Page<super::SitePageDocument>> {
241 self.ensure_session()?;
242 let fallback_domain = query.domain.clone();
243 let call = super::wire::build_list_pages_rpc_call(query);
244 let raw = self.call(call)?;
245 super::wire::normalize_page_list(&fallback_domain, raw)
246 }
247
248 pub(crate) fn get_page(
249 mut self,
250 page: super::SitePageRef,
251 ) -> crate::ImResult<super::SitePageDocument> {
252 self.ensure_session()?;
253 let fallback_domain = page.domain.clone();
254 let fallback_slug = page.slug.clone();
255 let call = super::wire::build_get_page_rpc_call(page);
256 let raw = self.call(call)?;
257 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
258 }
259
260 pub(crate) fn create_page(
261 mut self,
262 draft: super::SitePageDraft,
263 ) -> crate::ImResult<super::SitePageDocument> {
264 self.ensure_session()?;
265 let fallback_domain = draft.domain.clone();
266 let fallback_slug = draft.slug.clone();
267 let call = super::wire::build_create_page_rpc_call(draft);
268 let raw = self.call(call)?;
269 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
270 }
271
272 pub(crate) fn update_page(
273 mut self,
274 page: super::SitePageRef,
275 patch: super::SitePageUpdate,
276 ) -> crate::ImResult<super::SitePageDocument> {
277 self.ensure_session()?;
278 let fallback_domain = page.domain.clone();
279 let fallback_slug = page.slug.clone();
280 let call = super::wire::build_update_page_rpc_call(page, patch);
281 let raw = self.call(call)?;
282 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
283 }
284
285 pub(crate) fn rename_page(
286 mut self,
287 page: super::SitePageRef,
288 target: crate::content::PageSlug,
289 ) -> crate::ImResult<super::SitePageDocument> {
290 self.ensure_session()?;
291 let fallback_domain = page.domain.clone();
292 let fallback_slug = target.clone();
293 let call = super::wire::build_rename_page_rpc_call(page, target);
294 let raw = self.call(call)?;
295 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
296 }
297
298 pub(crate) fn delete_page(
299 mut self,
300 page: super::SitePageRef,
301 ) -> crate::ImResult<crate::content::PageDeleteResult> {
302 self.ensure_session()?;
303 let call = super::wire::build_delete_page_rpc_call(page);
304 let raw = self.call(call)?;
305 Ok(super::wire::normalize_delete(raw))
306 }
307
308 fn ensure_session(&self) -> crate::ImResult<crate::auth::SessionBundle> {
309 self.session_provider
310 .ensure_session(crate::auth::AuthScope::Messaging)
311 }
312
313 fn call(&mut self, call: super::wire::RpcCall) -> crate::ImResult<serde_json::Value> {
314 self.transport
315 .authenticated_rpc(call.endpoint, call.method, call.params)
316 }
317}
318
319impl<P, T> SiteRuntime<P, T>
320where
321 P: AsyncSessionProvider,
322 T: AsyncAuthenticatedRpcTransport,
323{
324 pub(crate) async fn get_root_async(
325 mut self,
326 domain: super::SiteDomain,
327 ) -> crate::ImResult<super::SiteRootDocument> {
328 self.ensure_session_async().await?;
329 let fallback_domain = domain.clone();
330 let call = super::wire::build_get_root_rpc_call(domain);
331 let raw = self.call_async(call).await?;
332 super::wire::normalize_root(raw, &fallback_domain)
333 }
334
335 pub(crate) async fn set_root_async(
336 mut self,
337 draft: super::SiteRootDraft,
338 ) -> crate::ImResult<super::SiteRootDocument> {
339 self.ensure_session_async().await?;
340 let fallback_domain = draft.domain.clone();
341 let call = super::wire::build_set_root_rpc_call(draft);
342 let raw = self.call_async(call).await?;
343 super::wire::normalize_root(raw, &fallback_domain)
344 }
345
346 pub(crate) async fn list_pages_async(
347 mut self,
348 query: super::SitePageQuery,
349 ) -> crate::ImResult<crate::ids::Page<super::SitePageDocument>> {
350 self.ensure_session_async().await?;
351 let fallback_domain = query.domain.clone();
352 let call = super::wire::build_list_pages_rpc_call(query);
353 let raw = self.call_async(call).await?;
354 super::wire::normalize_page_list(&fallback_domain, raw)
355 }
356
357 pub(crate) async fn get_page_async(
358 mut self,
359 page: super::SitePageRef,
360 ) -> crate::ImResult<super::SitePageDocument> {
361 self.ensure_session_async().await?;
362 let fallback_domain = page.domain.clone();
363 let fallback_slug = page.slug.clone();
364 let call = super::wire::build_get_page_rpc_call(page);
365 let raw = self.call_async(call).await?;
366 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
367 }
368
369 pub(crate) async fn create_page_async(
370 mut self,
371 draft: super::SitePageDraft,
372 ) -> crate::ImResult<super::SitePageDocument> {
373 self.ensure_session_async().await?;
374 let fallback_domain = draft.domain.clone();
375 let fallback_slug = draft.slug.clone();
376 let call = super::wire::build_create_page_rpc_call(draft);
377 let raw = self.call_async(call).await?;
378 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
379 }
380
381 pub(crate) async fn update_page_async(
382 mut self,
383 page: super::SitePageRef,
384 patch: super::SitePageUpdate,
385 ) -> crate::ImResult<super::SitePageDocument> {
386 self.ensure_session_async().await?;
387 let fallback_domain = page.domain.clone();
388 let fallback_slug = page.slug.clone();
389 let call = super::wire::build_update_page_rpc_call(page, patch);
390 let raw = self.call_async(call).await?;
391 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
392 }
393
394 pub(crate) async fn rename_page_async(
395 mut self,
396 page: super::SitePageRef,
397 target: crate::content::PageSlug,
398 ) -> crate::ImResult<super::SitePageDocument> {
399 self.ensure_session_async().await?;
400 let fallback_domain = page.domain.clone();
401 let fallback_slug = target.clone();
402 let call = super::wire::build_rename_page_rpc_call(page, target);
403 let raw = self.call_async(call).await?;
404 super::wire::normalize_page(raw, &fallback_domain, Some(&fallback_slug))
405 }
406
407 pub(crate) async fn delete_page_async(
408 mut self,
409 page: super::SitePageRef,
410 ) -> crate::ImResult<crate::content::PageDeleteResult> {
411 self.ensure_session_async().await?;
412 let call = super::wire::build_delete_page_rpc_call(page);
413 let raw = self.call_async(call).await?;
414 Ok(super::wire::normalize_delete(raw))
415 }
416
417 async fn ensure_session_async(&self) -> crate::ImResult<crate::auth::SessionBundle> {
418 self.session_provider
419 .ensure_session(crate::auth::AuthScope::Messaging)
420 .await
421 }
422
423 async fn call_async(
424 &mut self,
425 call: super::wire::RpcCall,
426 ) -> crate::ImResult<serde_json::Value> {
427 self.transport
428 .authenticated_rpc(call.endpoint, call.method, call.params)
429 .await
430 }
431}