mas_router/
endpoints.rs

1// Copyright 2024 New Vector Ltd.
2// Copyright 2022-2024 The Matrix.org Foundation C.I.C.
3//
4// SPDX-License-Identifier: AGPL-3.0-only
5// Please see LICENSE in the repository root for full details.
6
7use serde::{Deserialize, Serialize};
8use ulid::Ulid;
9
10use crate::UrlBuilder;
11pub use crate::traits::*;
12
13#[derive(Deserialize, Serialize, Clone, Debug)]
14#[serde(rename_all = "snake_case", tag = "kind")]
15pub enum PostAuthAction {
16    ContinueAuthorizationGrant {
17        id: Ulid,
18    },
19    ContinueDeviceCodeGrant {
20        id: Ulid,
21    },
22    ContinueCompatSsoLogin {
23        id: Ulid,
24    },
25    ChangePassword,
26    LinkUpstream {
27        id: Ulid,
28    },
29    ManageAccount {
30        #[serde(flatten)]
31        action: Option<AccountAction>,
32    },
33}
34
35impl PostAuthAction {
36    #[must_use]
37    pub const fn continue_grant(id: Ulid) -> Self {
38        PostAuthAction::ContinueAuthorizationGrant { id }
39    }
40
41    #[must_use]
42    pub const fn continue_device_code_grant(id: Ulid) -> Self {
43        PostAuthAction::ContinueDeviceCodeGrant { id }
44    }
45
46    #[must_use]
47    pub const fn continue_compat_sso_login(id: Ulid) -> Self {
48        PostAuthAction::ContinueCompatSsoLogin { id }
49    }
50
51    #[must_use]
52    pub const fn link_upstream(id: Ulid) -> Self {
53        PostAuthAction::LinkUpstream { id }
54    }
55
56    #[must_use]
57    pub const fn manage_account(action: Option<AccountAction>) -> Self {
58        PostAuthAction::ManageAccount { action }
59    }
60
61    pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
62        match self {
63            Self::ContinueAuthorizationGrant { id } => url_builder.redirect(&Consent(*id)),
64            Self::ContinueDeviceCodeGrant { id } => {
65                url_builder.redirect(&DeviceCodeConsent::new(*id))
66            }
67            Self::ContinueCompatSsoLogin { id } => {
68                url_builder.redirect(&CompatLoginSsoComplete::new(*id, None))
69            }
70            Self::ChangePassword => url_builder.redirect(&AccountPasswordChange),
71            Self::LinkUpstream { id } => url_builder.redirect(&UpstreamOAuth2Link::new(*id)),
72            Self::ManageAccount { action } => url_builder.redirect(&Account {
73                action: action.clone(),
74            }),
75        }
76    }
77}
78
79/// `GET /.well-known/openid-configuration`
80#[derive(Default, Debug, Clone)]
81pub struct OidcConfiguration;
82
83impl SimpleRoute for OidcConfiguration {
84    const PATH: &'static str = "/.well-known/openid-configuration";
85}
86
87/// `GET /.well-known/webfinger`
88#[derive(Default, Debug, Clone)]
89pub struct Webfinger;
90
91impl SimpleRoute for Webfinger {
92    const PATH: &'static str = "/.well-known/webfinger";
93}
94
95/// `GET /.well-known/change-password`
96pub struct ChangePasswordDiscovery;
97
98impl SimpleRoute for ChangePasswordDiscovery {
99    const PATH: &'static str = "/.well-known/change-password";
100}
101
102/// `GET /oauth2/keys.json`
103#[derive(Default, Debug, Clone)]
104pub struct OAuth2Keys;
105
106impl SimpleRoute for OAuth2Keys {
107    const PATH: &'static str = "/oauth2/keys.json";
108}
109
110/// `GET /oauth2/userinfo`
111#[derive(Default, Debug, Clone)]
112pub struct OidcUserinfo;
113
114impl SimpleRoute for OidcUserinfo {
115    const PATH: &'static str = "/oauth2/userinfo";
116}
117
118/// `POST /oauth2/introspect`
119#[derive(Default, Debug, Clone)]
120pub struct OAuth2Introspection;
121
122impl SimpleRoute for OAuth2Introspection {
123    const PATH: &'static str = "/oauth2/introspect";
124}
125
126/// `POST /oauth2/revoke`
127#[derive(Default, Debug, Clone)]
128pub struct OAuth2Revocation;
129
130impl SimpleRoute for OAuth2Revocation {
131    const PATH: &'static str = "/oauth2/revoke";
132}
133
134/// `POST /oauth2/token`
135#[derive(Default, Debug, Clone)]
136pub struct OAuth2TokenEndpoint;
137
138impl SimpleRoute for OAuth2TokenEndpoint {
139    const PATH: &'static str = "/oauth2/token";
140}
141
142/// `POST /oauth2/registration`
143#[derive(Default, Debug, Clone)]
144pub struct OAuth2RegistrationEndpoint;
145
146impl SimpleRoute for OAuth2RegistrationEndpoint {
147    const PATH: &'static str = "/oauth2/registration";
148}
149
150/// `GET /authorize`
151#[derive(Default, Debug, Clone)]
152pub struct OAuth2AuthorizationEndpoint;
153
154impl SimpleRoute for OAuth2AuthorizationEndpoint {
155    const PATH: &'static str = "/authorize";
156}
157
158/// `GET /`
159#[derive(Default, Debug, Clone)]
160pub struct Index;
161
162impl SimpleRoute for Index {
163    const PATH: &'static str = "/";
164}
165
166/// `GET /health`
167#[derive(Default, Debug, Clone)]
168pub struct Healthcheck;
169
170impl SimpleRoute for Healthcheck {
171    const PATH: &'static str = "/health";
172}
173
174/// `GET|POST /login`
175#[derive(Default, Debug, Clone)]
176pub struct Login {
177    post_auth_action: Option<PostAuthAction>,
178}
179
180impl Route for Login {
181    type Query = PostAuthAction;
182
183    fn route() -> &'static str {
184        "/login"
185    }
186
187    fn query(&self) -> Option<&Self::Query> {
188        self.post_auth_action.as_ref()
189    }
190}
191
192impl Login {
193    #[must_use]
194    pub const fn and_then(action: PostAuthAction) -> Self {
195        Self {
196            post_auth_action: Some(action),
197        }
198    }
199
200    #[must_use]
201    pub const fn and_continue_grant(id: Ulid) -> Self {
202        Self {
203            post_auth_action: Some(PostAuthAction::continue_grant(id)),
204        }
205    }
206
207    #[must_use]
208    pub const fn and_continue_device_code_grant(id: Ulid) -> Self {
209        Self {
210            post_auth_action: Some(PostAuthAction::continue_device_code_grant(id)),
211        }
212    }
213
214    #[must_use]
215    pub const fn and_continue_compat_sso_login(id: Ulid) -> Self {
216        Self {
217            post_auth_action: Some(PostAuthAction::continue_compat_sso_login(id)),
218        }
219    }
220
221    #[must_use]
222    pub const fn and_link_upstream(id: Ulid) -> Self {
223        Self {
224            post_auth_action: Some(PostAuthAction::link_upstream(id)),
225        }
226    }
227
228    /// Get a reference to the login's post auth action.
229    #[must_use]
230    pub fn post_auth_action(&self) -> Option<&PostAuthAction> {
231        self.post_auth_action.as_ref()
232    }
233
234    pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
235        match &self.post_auth_action {
236            Some(action) => action.go_next(url_builder),
237            None => url_builder.redirect(&Index),
238        }
239    }
240}
241
242impl From<Option<PostAuthAction>> for Login {
243    fn from(post_auth_action: Option<PostAuthAction>) -> Self {
244        Self { post_auth_action }
245    }
246}
247
248/// `POST /logout`
249#[derive(Default, Debug, Clone)]
250pub struct Logout;
251
252impl SimpleRoute for Logout {
253    const PATH: &'static str = "/logout";
254}
255
256/// `POST /register`
257#[derive(Default, Debug, Clone)]
258pub struct Register {
259    post_auth_action: Option<PostAuthAction>,
260}
261
262impl Register {
263    #[must_use]
264    pub fn and_then(action: PostAuthAction) -> Self {
265        Self {
266            post_auth_action: Some(action),
267        }
268    }
269
270    #[must_use]
271    pub fn and_continue_grant(data: Ulid) -> Self {
272        Self {
273            post_auth_action: Some(PostAuthAction::continue_grant(data)),
274        }
275    }
276
277    #[must_use]
278    pub fn and_continue_compat_sso_login(data: Ulid) -> Self {
279        Self {
280            post_auth_action: Some(PostAuthAction::continue_compat_sso_login(data)),
281        }
282    }
283
284    /// Get a reference to the reauth's post auth action.
285    #[must_use]
286    pub fn post_auth_action(&self) -> Option<&PostAuthAction> {
287        self.post_auth_action.as_ref()
288    }
289
290    pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
291        match &self.post_auth_action {
292            Some(action) => action.go_next(url_builder),
293            None => url_builder.redirect(&Index),
294        }
295    }
296}
297
298impl Route for Register {
299    type Query = PostAuthAction;
300
301    fn route() -> &'static str {
302        "/register"
303    }
304
305    fn query(&self) -> Option<&Self::Query> {
306        self.post_auth_action.as_ref()
307    }
308}
309
310impl From<Option<PostAuthAction>> for Register {
311    fn from(post_auth_action: Option<PostAuthAction>) -> Self {
312        Self { post_auth_action }
313    }
314}
315
316/// `GET|POST /register/password`
317#[derive(Default, Debug, Clone, Serialize, Deserialize)]
318pub struct PasswordRegister {
319    username: Option<String>,
320
321    #[serde(flatten)]
322    post_auth_action: Option<PostAuthAction>,
323}
324
325impl PasswordRegister {
326    #[must_use]
327    pub fn and_then(mut self, action: PostAuthAction) -> Self {
328        self.post_auth_action = Some(action);
329        self
330    }
331
332    #[must_use]
333    pub fn and_continue_grant(mut self, data: Ulid) -> Self {
334        self.post_auth_action = Some(PostAuthAction::continue_grant(data));
335        self
336    }
337
338    #[must_use]
339    pub fn and_continue_compat_sso_login(mut self, data: Ulid) -> Self {
340        self.post_auth_action = Some(PostAuthAction::continue_compat_sso_login(data));
341        self
342    }
343
344    /// Get a reference to the post auth action.
345    #[must_use]
346    pub fn post_auth_action(&self) -> Option<&PostAuthAction> {
347        self.post_auth_action.as_ref()
348    }
349
350    /// Get a reference to the username chosen by the user.
351    #[must_use]
352    pub fn username(&self) -> Option<&str> {
353        self.username.as_deref()
354    }
355
356    pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
357        match &self.post_auth_action {
358            Some(action) => action.go_next(url_builder),
359            None => url_builder.redirect(&Index),
360        }
361    }
362}
363
364impl Route for PasswordRegister {
365    type Query = Self;
366
367    fn route() -> &'static str {
368        "/register/password"
369    }
370
371    fn query(&self) -> Option<&Self::Query> {
372        Some(self)
373    }
374}
375
376impl From<Option<PostAuthAction>> for PasswordRegister {
377    fn from(post_auth_action: Option<PostAuthAction>) -> Self {
378        Self {
379            username: None,
380            post_auth_action,
381        }
382    }
383}
384
385/// `GET|POST /register/steps/{id}/token`
386#[derive(Debug, Clone)]
387pub struct RegisterToken {
388    id: Ulid,
389}
390
391impl RegisterToken {
392    #[must_use]
393    pub fn new(id: Ulid) -> Self {
394        Self { id }
395    }
396}
397
398impl Route for RegisterToken {
399    type Query = ();
400    fn route() -> &'static str {
401        "/register/steps/{id}/token"
402    }
403
404    fn path(&self) -> std::borrow::Cow<'static, str> {
405        format!("/register/steps/{}/token", self.id).into()
406    }
407}
408
409/// `GET|POST /register/steps/{id}/display-name`
410#[derive(Debug, Clone)]
411pub struct RegisterDisplayName {
412    id: Ulid,
413}
414
415impl RegisterDisplayName {
416    #[must_use]
417    pub fn new(id: Ulid) -> Self {
418        Self { id }
419    }
420}
421
422impl Route for RegisterDisplayName {
423    type Query = ();
424    fn route() -> &'static str {
425        "/register/steps/{id}/display-name"
426    }
427
428    fn path(&self) -> std::borrow::Cow<'static, str> {
429        format!("/register/steps/{}/display-name", self.id).into()
430    }
431}
432
433/// `GET|POST /register/steps/{id}/verify-email`
434#[derive(Debug, Clone)]
435pub struct RegisterVerifyEmail {
436    id: Ulid,
437}
438
439impl RegisterVerifyEmail {
440    #[must_use]
441    pub fn new(id: Ulid) -> Self {
442        Self { id }
443    }
444}
445
446impl Route for RegisterVerifyEmail {
447    type Query = ();
448    fn route() -> &'static str {
449        "/register/steps/{id}/verify-email"
450    }
451
452    fn path(&self) -> std::borrow::Cow<'static, str> {
453        format!("/register/steps/{}/verify-email", self.id).into()
454    }
455}
456
457/// `GET /register/steps/{id}/finish`
458#[derive(Debug, Clone)]
459pub struct RegisterFinish {
460    id: Ulid,
461}
462
463impl RegisterFinish {
464    #[must_use]
465    pub const fn new(id: Ulid) -> Self {
466        Self { id }
467    }
468}
469
470impl Route for RegisterFinish {
471    type Query = ();
472    fn route() -> &'static str {
473        "/register/steps/{id}/finish"
474    }
475
476    fn path(&self) -> std::borrow::Cow<'static, str> {
477        format!("/register/steps/{}/finish", self.id).into()
478    }
479}
480
481/// Actions parameters as defined by MSC2965
482#[derive(Debug, Clone, Serialize, Deserialize)]
483#[serde(tag = "action")]
484pub enum AccountAction {
485    #[serde(rename = "org.matrix.profile")]
486    OrgMatrixProfile,
487    #[serde(rename = "profile")]
488    Profile,
489
490    #[serde(rename = "org.matrix.sessions_list")]
491    OrgMatrixSessionsList,
492    #[serde(rename = "sessions_list")]
493    SessionsList,
494
495    #[serde(rename = "org.matrix.session_view")]
496    OrgMatrixSessionView { device_id: String },
497    #[serde(rename = "session_view")]
498    SessionView { device_id: String },
499
500    #[serde(rename = "org.matrix.session_end")]
501    OrgMatrixSessionEnd { device_id: String },
502    #[serde(rename = "session_end")]
503    SessionEnd { device_id: String },
504
505    #[serde(rename = "org.matrix.cross_signing_reset")]
506    OrgMatrixCrossSigningReset,
507}
508
509/// `GET /account/`
510#[derive(Default, Debug, Clone)]
511pub struct Account {
512    action: Option<AccountAction>,
513}
514
515impl Route for Account {
516    type Query = AccountAction;
517
518    fn route() -> &'static str {
519        "/account/"
520    }
521
522    fn query(&self) -> Option<&Self::Query> {
523        self.action.as_ref()
524    }
525}
526
527/// `GET /account/*`
528#[derive(Default, Debug, Clone)]
529pub struct AccountWildcard;
530
531impl SimpleRoute for AccountWildcard {
532    const PATH: &'static str = "/account/{*rest}";
533}
534
535/// `GET /account/password/change`
536///
537/// Handled by the React frontend; this struct definition is purely for
538/// redirects.
539#[derive(Default, Debug, Clone)]
540pub struct AccountPasswordChange;
541
542impl SimpleRoute for AccountPasswordChange {
543    const PATH: &'static str = "/account/password/change";
544}
545
546/// `GET /consent/{grant_id}`
547#[derive(Debug, Clone)]
548pub struct Consent(pub Ulid);
549
550impl Route for Consent {
551    type Query = ();
552    fn route() -> &'static str {
553        "/consent/{grant_id}"
554    }
555
556    fn path(&self) -> std::borrow::Cow<'static, str> {
557        format!("/consent/{}", self.0).into()
558    }
559}
560
561/// `GET|POST /_matrix/client/v3/login`
562pub struct CompatLogin;
563
564impl SimpleRoute for CompatLogin {
565    const PATH: &'static str = "/_matrix/client/{version}/login";
566}
567
568/// `POST /_matrix/client/v3/logout`
569pub struct CompatLogout;
570
571impl SimpleRoute for CompatLogout {
572    const PATH: &'static str = "/_matrix/client/{version}/logout";
573}
574
575/// `POST /_matrix/client/v3/logout/all`
576pub struct CompatLogoutAll;
577
578impl SimpleRoute for CompatLogoutAll {
579    const PATH: &'static str = "/_matrix/client/{version}/logout/all";
580}
581
582/// `POST /_matrix/client/v3/refresh`
583pub struct CompatRefresh;
584
585impl SimpleRoute for CompatRefresh {
586    const PATH: &'static str = "/_matrix/client/{version}/refresh";
587}
588
589/// `GET /_matrix/client/v3/login/sso/redirect`
590pub struct CompatLoginSsoRedirect;
591
592impl SimpleRoute for CompatLoginSsoRedirect {
593    const PATH: &'static str = "/_matrix/client/{version}/login/sso/redirect";
594}
595
596/// `GET /_matrix/client/v3/login/sso/redirect/`
597///
598/// This is a workaround for the fact some clients (Element iOS) sends a
599/// trailing slash, even though it's not in the spec.
600pub struct CompatLoginSsoRedirectSlash;
601
602impl SimpleRoute for CompatLoginSsoRedirectSlash {
603    const PATH: &'static str = "/_matrix/client/{version}/login/sso/redirect/";
604}
605
606/// `GET /_matrix/client/v3/login/sso/redirect/{idp}`
607pub struct CompatLoginSsoRedirectIdp;
608
609impl SimpleRoute for CompatLoginSsoRedirectIdp {
610    const PATH: &'static str = "/_matrix/client/{version}/login/sso/redirect/{idp}";
611}
612
613#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
614#[serde(rename_all = "lowercase")]
615pub enum CompatLoginSsoAction {
616    Login,
617    Register,
618}
619
620#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
621pub struct CompatLoginSsoActionParams {
622    #[serde(rename = "org.matrix.msc3824.action")]
623    action: CompatLoginSsoAction,
624}
625
626/// `GET|POST /complete-compat-sso/{id}`
627pub struct CompatLoginSsoComplete {
628    id: Ulid,
629    query: Option<CompatLoginSsoActionParams>,
630}
631
632impl CompatLoginSsoComplete {
633    #[must_use]
634    pub fn new(id: Ulid, action: Option<CompatLoginSsoAction>) -> Self {
635        Self {
636            id,
637            query: action.map(|action| CompatLoginSsoActionParams { action }),
638        }
639    }
640}
641
642impl Route for CompatLoginSsoComplete {
643    type Query = CompatLoginSsoActionParams;
644
645    fn query(&self) -> Option<&Self::Query> {
646        self.query.as_ref()
647    }
648
649    fn route() -> &'static str {
650        "/complete-compat-sso/{grant_id}"
651    }
652
653    fn path(&self) -> std::borrow::Cow<'static, str> {
654        format!("/complete-compat-sso/{}", self.id).into()
655    }
656}
657
658/// `GET /upstream/authorize/{id}`
659pub struct UpstreamOAuth2Authorize {
660    id: Ulid,
661    post_auth_action: Option<PostAuthAction>,
662}
663
664impl UpstreamOAuth2Authorize {
665    #[must_use]
666    pub const fn new(id: Ulid) -> Self {
667        Self {
668            id,
669            post_auth_action: None,
670        }
671    }
672
673    #[must_use]
674    pub fn and_then(mut self, action: PostAuthAction) -> Self {
675        self.post_auth_action = Some(action);
676        self
677    }
678}
679
680impl Route for UpstreamOAuth2Authorize {
681    type Query = PostAuthAction;
682    fn route() -> &'static str {
683        "/upstream/authorize/{provider_id}"
684    }
685
686    fn path(&self) -> std::borrow::Cow<'static, str> {
687        format!("/upstream/authorize/{}", self.id).into()
688    }
689
690    fn query(&self) -> Option<&Self::Query> {
691        self.post_auth_action.as_ref()
692    }
693}
694
695/// `GET /upstream/callback/{id}`
696pub struct UpstreamOAuth2Callback {
697    id: Ulid,
698}
699
700impl UpstreamOAuth2Callback {
701    #[must_use]
702    pub const fn new(id: Ulid) -> Self {
703        Self { id }
704    }
705}
706
707impl Route for UpstreamOAuth2Callback {
708    type Query = ();
709    fn route() -> &'static str {
710        "/upstream/callback/{provider_id}"
711    }
712
713    fn path(&self) -> std::borrow::Cow<'static, str> {
714        format!("/upstream/callback/{}", self.id).into()
715    }
716}
717
718/// `GET /upstream/link/{id}`
719pub struct UpstreamOAuth2Link {
720    id: Ulid,
721}
722
723impl UpstreamOAuth2Link {
724    #[must_use]
725    pub const fn new(id: Ulid) -> Self {
726        Self { id }
727    }
728}
729
730impl Route for UpstreamOAuth2Link {
731    type Query = ();
732    fn route() -> &'static str {
733        "/upstream/link/{link_id}"
734    }
735
736    fn path(&self) -> std::borrow::Cow<'static, str> {
737        format!("/upstream/link/{}", self.id).into()
738    }
739}
740
741/// `GET|POST /link`
742#[derive(Default, Serialize, Deserialize, Debug, Clone)]
743pub struct DeviceCodeLink {
744    code: Option<String>,
745}
746
747impl DeviceCodeLink {
748    #[must_use]
749    pub fn with_code(code: String) -> Self {
750        Self { code: Some(code) }
751    }
752}
753
754impl Route for DeviceCodeLink {
755    type Query = DeviceCodeLink;
756    fn route() -> &'static str {
757        "/link"
758    }
759
760    fn query(&self) -> Option<&Self::Query> {
761        Some(self)
762    }
763}
764
765/// `GET|POST /device/{device_code_id}`
766#[derive(Default, Serialize, Deserialize, Debug, Clone)]
767pub struct DeviceCodeConsent {
768    id: Ulid,
769}
770
771impl Route for DeviceCodeConsent {
772    type Query = ();
773    fn route() -> &'static str {
774        "/device/{device_code_id}"
775    }
776
777    fn path(&self) -> std::borrow::Cow<'static, str> {
778        format!("/device/{}", self.id).into()
779    }
780}
781
782impl DeviceCodeConsent {
783    #[must_use]
784    pub fn new(id: Ulid) -> Self {
785        Self { id }
786    }
787}
788
789/// `POST /oauth2/device`
790#[derive(Default, Serialize, Deserialize, Debug, Clone)]
791pub struct OAuth2DeviceAuthorizationEndpoint;
792
793impl SimpleRoute for OAuth2DeviceAuthorizationEndpoint {
794    const PATH: &'static str = "/oauth2/device";
795}
796
797/// `GET|POST /recover`
798#[derive(Default, Serialize, Deserialize, Debug, Clone)]
799pub struct AccountRecoveryStart;
800
801impl SimpleRoute for AccountRecoveryStart {
802    const PATH: &'static str = "/recover";
803}
804
805/// `GET|POST /recover/progress/{session_id}`
806#[derive(Default, Serialize, Deserialize, Debug, Clone)]
807pub struct AccountRecoveryProgress {
808    session_id: Ulid,
809}
810
811impl AccountRecoveryProgress {
812    #[must_use]
813    pub fn new(session_id: Ulid) -> Self {
814        Self { session_id }
815    }
816}
817
818impl Route for AccountRecoveryProgress {
819    type Query = ();
820    fn route() -> &'static str {
821        "/recover/progress/{session_id}"
822    }
823
824    fn path(&self) -> std::borrow::Cow<'static, str> {
825        format!("/recover/progress/{}", self.session_id).into()
826    }
827}
828
829/// `GET /account/password/recovery?ticket=:ticket`
830/// Rendered by the React frontend
831#[derive(Default, Serialize, Deserialize, Debug, Clone)]
832pub struct AccountRecoveryFinish {
833    ticket: String,
834}
835
836impl AccountRecoveryFinish {
837    #[must_use]
838    pub fn new(ticket: String) -> Self {
839        Self { ticket }
840    }
841}
842
843impl Route for AccountRecoveryFinish {
844    type Query = AccountRecoveryFinish;
845
846    fn route() -> &'static str {
847        "/account/password/recovery"
848    }
849
850    fn query(&self) -> Option<&Self::Query> {
851        Some(self)
852    }
853}
854
855/// `GET /assets`
856pub struct StaticAsset {
857    path: String,
858}
859
860impl StaticAsset {
861    #[must_use]
862    pub fn new(path: String) -> Self {
863        Self { path }
864    }
865}
866
867impl Route for StaticAsset {
868    type Query = ();
869    fn route() -> &'static str {
870        "/assets/"
871    }
872
873    fn path(&self) -> std::borrow::Cow<'static, str> {
874        format!("/assets/{}", self.path).into()
875    }
876}
877
878/// `GET|POST /graphql`
879pub struct GraphQL;
880
881impl SimpleRoute for GraphQL {
882    const PATH: &'static str = "/graphql";
883}
884
885/// `GET /graphql/playground`
886pub struct GraphQLPlayground;
887
888impl SimpleRoute for GraphQLPlayground {
889    const PATH: &'static str = "/graphql/playground";
890}
891
892/// `GET /api/spec.json`
893pub struct ApiSpec;
894
895impl SimpleRoute for ApiSpec {
896    const PATH: &'static str = "/api/spec.json";
897}
898
899/// `GET /api/doc/`
900pub struct ApiDoc;
901
902impl SimpleRoute for ApiDoc {
903    const PATH: &'static str = "/api/doc/";
904}
905
906/// `GET /api/doc/oauth2-callback`
907pub struct ApiDocCallback;
908
909impl SimpleRoute for ApiDocCallback {
910    const PATH: &'static str = "/api/doc/oauth2-callback";
911}
mas_router/endpoints.rs

mas_router/
endpoints.rs
