use serde::{Deserialize, Serialize};
use ulid::Ulid;
pub use crate::traits::*;
use crate::UrlBuilder;
#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(rename_all = "snake_case", tag = "kind")]
pub enum PostAuthAction {
ContinueAuthorizationGrant {
id: Ulid,
},
ContinueDeviceCodeGrant {
id: Ulid,
},
ContinueCompatSsoLogin {
id: Ulid,
},
ChangePassword,
LinkUpstream {
id: Ulid,
},
ManageAccount {
#[serde(flatten)]
action: Option<AccountAction>,
},
}
impl PostAuthAction {
#[must_use]
pub const fn continue_grant(id: Ulid) -> Self {
PostAuthAction::ContinueAuthorizationGrant { id }
}
#[must_use]
pub const fn continue_device_code_grant(id: Ulid) -> Self {
PostAuthAction::ContinueDeviceCodeGrant { id }
}
#[must_use]
pub const fn continue_compat_sso_login(id: Ulid) -> Self {
PostAuthAction::ContinueCompatSsoLogin { id }
}
#[must_use]
pub const fn link_upstream(id: Ulid) -> Self {
PostAuthAction::LinkUpstream { id }
}
#[must_use]
pub const fn manage_account(action: Option<AccountAction>) -> Self {
PostAuthAction::ManageAccount { action }
}
pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
match self {
Self::ContinueAuthorizationGrant { id } => {
url_builder.redirect(&ContinueAuthorizationGrant(*id))
}
Self::ContinueDeviceCodeGrant { id } => {
url_builder.redirect(&DeviceCodeConsent::new(*id))
}
Self::ContinueCompatSsoLogin { id } => {
url_builder.redirect(&CompatLoginSsoComplete::new(*id, None))
}
Self::ChangePassword => url_builder.redirect(&AccountPasswordChange),
Self::LinkUpstream { id } => url_builder.redirect(&UpstreamOAuth2Link::new(*id)),
Self::ManageAccount { action } => url_builder.redirect(&Account {
action: action.clone(),
}),
}
}
}
#[derive(Default, Debug, Clone)]
pub struct OidcConfiguration;
impl SimpleRoute for OidcConfiguration {
const PATH: &'static str = "/.well-known/openid-configuration";
}
#[derive(Default, Debug, Clone)]
pub struct Webfinger;
impl SimpleRoute for Webfinger {
const PATH: &'static str = "/.well-known/webfinger";
}
pub struct ChangePasswordDiscovery;
impl SimpleRoute for ChangePasswordDiscovery {
const PATH: &'static str = "/.well-known/change-password";
}
#[derive(Default, Debug, Clone)]
pub struct OAuth2Keys;
impl SimpleRoute for OAuth2Keys {
const PATH: &'static str = "/oauth2/keys.json";
}
#[derive(Default, Debug, Clone)]
pub struct OidcUserinfo;
impl SimpleRoute for OidcUserinfo {
const PATH: &'static str = "/oauth2/userinfo";
}
#[derive(Default, Debug, Clone)]
pub struct OAuth2Introspection;
impl SimpleRoute for OAuth2Introspection {
const PATH: &'static str = "/oauth2/introspect";
}
#[derive(Default, Debug, Clone)]
pub struct OAuth2Revocation;
impl SimpleRoute for OAuth2Revocation {
const PATH: &'static str = "/oauth2/revoke";
}
#[derive(Default, Debug, Clone)]
pub struct OAuth2TokenEndpoint;
impl SimpleRoute for OAuth2TokenEndpoint {
const PATH: &'static str = "/oauth2/token";
}
#[derive(Default, Debug, Clone)]
pub struct OAuth2RegistrationEndpoint;
impl SimpleRoute for OAuth2RegistrationEndpoint {
const PATH: &'static str = "/oauth2/registration";
}
#[derive(Default, Debug, Clone)]
pub struct OAuth2AuthorizationEndpoint;
impl SimpleRoute for OAuth2AuthorizationEndpoint {
const PATH: &'static str = "/authorize";
}
#[derive(Default, Debug, Clone)]
pub struct Index;
impl SimpleRoute for Index {
const PATH: &'static str = "/";
}
#[derive(Default, Debug, Clone)]
pub struct Healthcheck;
impl SimpleRoute for Healthcheck {
const PATH: &'static str = "/health";
}
#[derive(Default, Debug, Clone)]
pub struct Login {
post_auth_action: Option<PostAuthAction>,
}
impl Route for Login {
type Query = PostAuthAction;
fn route() -> &'static str {
"/login"
}
fn query(&self) -> Option<&Self::Query> {
self.post_auth_action.as_ref()
}
}
impl Login {
#[must_use]
pub const fn and_then(action: PostAuthAction) -> Self {
Self {
post_auth_action: Some(action),
}
}
#[must_use]
pub const fn and_continue_grant(id: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_grant(id)),
}
}
#[must_use]
pub const fn and_continue_device_code_grant(id: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_device_code_grant(id)),
}
}
#[must_use]
pub const fn and_continue_compat_sso_login(id: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_compat_sso_login(id)),
}
}
#[must_use]
pub const fn and_link_upstream(id: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::link_upstream(id)),
}
}
#[must_use]
pub fn post_auth_action(&self) -> Option<&PostAuthAction> {
self.post_auth_action.as_ref()
}
pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
match &self.post_auth_action {
Some(action) => action.go_next(url_builder),
None => url_builder.redirect(&Index),
}
}
}
impl From<Option<PostAuthAction>> for Login {
fn from(post_auth_action: Option<PostAuthAction>) -> Self {
Self { post_auth_action }
}
}
#[derive(Default, Debug, Clone)]
pub struct Logout;
impl SimpleRoute for Logout {
const PATH: &'static str = "/logout";
}
#[derive(Default, Debug, Clone)]
pub struct Reauth {
post_auth_action: Option<PostAuthAction>,
}
impl Reauth {
#[must_use]
pub fn and_then(action: PostAuthAction) -> Self {
Self {
post_auth_action: Some(action),
}
}
#[must_use]
pub fn and_continue_grant(data: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_grant(data)),
}
}
#[must_use]
pub fn and_continue_device_code_grant(data: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_device_code_grant(data)),
}
}
#[must_use]
pub fn post_auth_action(&self) -> Option<&PostAuthAction> {
self.post_auth_action.as_ref()
}
pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
match &self.post_auth_action {
Some(action) => action.go_next(url_builder),
None => url_builder.redirect(&Index),
}
}
}
impl Route for Reauth {
type Query = PostAuthAction;
fn route() -> &'static str {
"/reauth"
}
fn query(&self) -> Option<&Self::Query> {
self.post_auth_action.as_ref()
}
}
impl From<Option<PostAuthAction>> for Reauth {
fn from(post_auth_action: Option<PostAuthAction>) -> Self {
Self { post_auth_action }
}
}
#[derive(Default, Debug, Clone)]
pub struct Register {
post_auth_action: Option<PostAuthAction>,
}
impl Register {
#[must_use]
pub fn and_then(action: PostAuthAction) -> Self {
Self {
post_auth_action: Some(action),
}
}
#[must_use]
pub fn and_continue_grant(data: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_grant(data)),
}
}
#[must_use]
pub fn and_continue_compat_sso_login(data: Ulid) -> Self {
Self {
post_auth_action: Some(PostAuthAction::continue_compat_sso_login(data)),
}
}
#[must_use]
pub fn post_auth_action(&self) -> Option<&PostAuthAction> {
self.post_auth_action.as_ref()
}
pub fn go_next(&self, url_builder: &UrlBuilder) -> axum::response::Redirect {
match &self.post_auth_action {
Some(action) => action.go_next(url_builder),
None => url_builder.redirect(&Index),
}
}
}
impl Route for Register {
type Query = PostAuthAction;
fn route() -> &'static str {
"/register"
}
fn query(&self) -> Option<&Self::Query> {
self.post_auth_action.as_ref()
}
}
impl From<Option<PostAuthAction>> for Register {
fn from(post_auth_action: Option<PostAuthAction>) -> Self {
Self { post_auth_action }
}
}
#[derive(Debug, Clone)]
pub struct AccountVerifyEmail {
id: Ulid,
post_auth_action: Option<PostAuthAction>,
}
impl AccountVerifyEmail {
#[must_use]
pub fn new(id: Ulid) -> Self {
Self {
id,
post_auth_action: None,
}
}
#[must_use]
pub fn and_maybe(mut self, action: Option<PostAuthAction>) -> Self {
self.post_auth_action = action;
self
}
#[must_use]
pub fn and_then(mut self, action: PostAuthAction) -> Self {
self.post_auth_action = Some(action);
self
}
}
impl Route for AccountVerifyEmail {
type Query = PostAuthAction;
fn route() -> &'static str {
"/verify-email/:id"
}
fn query(&self) -> Option<&Self::Query> {
self.post_auth_action.as_ref()
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/verify-email/{}", self.id).into()
}
}
#[derive(Default, Debug, Clone)]
pub struct AccountAddEmail {
post_auth_action: Option<PostAuthAction>,
}
impl Route for AccountAddEmail {
type Query = PostAuthAction;
fn route() -> &'static str {
"/add-email"
}
fn query(&self) -> Option<&Self::Query> {
self.post_auth_action.as_ref()
}
}
impl AccountAddEmail {
#[must_use]
pub fn and_then(mut self, action: PostAuthAction) -> Self {
self.post_auth_action = Some(action);
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "action")]
pub enum AccountAction {
#[serde(rename = "org.matrix.profile")]
OrgMatrixProfile,
#[serde(rename = "profile")]
Profile,
#[serde(rename = "org.matrix.sessions_list")]
OrgMatrixSessionsList,
#[serde(rename = "sessions_list")]
SessionsList,
#[serde(rename = "org.matrix.session_view")]
OrgMatrixSessionView { device_id: String },
#[serde(rename = "session_view")]
SessionView { device_id: String },
#[serde(rename = "org.matrix.session_end")]
OrgMatrixSessionEnd { device_id: String },
#[serde(rename = "session_end")]
SessionEnd { device_id: String },
#[serde(rename = "org.matrix.cross_signing_reset")]
OrgMatrixCrossSigningReset,
}
#[derive(Default, Debug, Clone)]
pub struct Account {
action: Option<AccountAction>,
}
impl Route for Account {
type Query = AccountAction;
fn route() -> &'static str {
"/account/"
}
fn query(&self) -> Option<&Self::Query> {
self.action.as_ref()
}
}
#[derive(Default, Debug, Clone)]
pub struct AccountWildcard;
impl SimpleRoute for AccountWildcard {
const PATH: &'static str = "/account/*rest";
}
#[derive(Default, Debug, Clone)]
pub struct AccountPasswordChange;
impl SimpleRoute for AccountPasswordChange {
const PATH: &'static str = "/account/password/change";
}
#[derive(Debug, Clone)]
pub struct ContinueAuthorizationGrant(pub Ulid);
impl Route for ContinueAuthorizationGrant {
type Query = ();
fn route() -> &'static str {
"/authorize/:grant_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/authorize/{}", self.0).into()
}
}
#[derive(Debug, Clone)]
pub struct Consent(pub Ulid);
impl Route for Consent {
type Query = ();
fn route() -> &'static str {
"/consent/:grant_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/consent/{}", self.0).into()
}
}
pub struct CompatLogin;
impl SimpleRoute for CompatLogin {
const PATH: &'static str = "/_matrix/client/:version/login";
}
pub struct CompatLogout;
impl SimpleRoute for CompatLogout {
const PATH: &'static str = "/_matrix/client/:version/logout";
}
pub struct CompatRefresh;
impl SimpleRoute for CompatRefresh {
const PATH: &'static str = "/_matrix/client/:version/refresh";
}
pub struct CompatLoginSsoRedirect;
impl SimpleRoute for CompatLoginSsoRedirect {
const PATH: &'static str = "/_matrix/client/:version/login/sso/redirect";
}
pub struct CompatLoginSsoRedirectSlash;
impl SimpleRoute for CompatLoginSsoRedirectSlash {
const PATH: &'static str = "/_matrix/client/:version/login/sso/redirect/";
}
pub struct CompatLoginSsoRedirectIdp;
impl SimpleRoute for CompatLoginSsoRedirectIdp {
const PATH: &'static str = "/_matrix/client/:version/login/sso/redirect/:idp";
}
#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum CompatLoginSsoAction {
Login,
Register,
}
#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub struct CompatLoginSsoActionParams {
#[serde(rename = "org.matrix.msc3824.action")]
action: CompatLoginSsoAction,
}
pub struct CompatLoginSsoComplete {
id: Ulid,
query: Option<CompatLoginSsoActionParams>,
}
impl CompatLoginSsoComplete {
#[must_use]
pub fn new(id: Ulid, action: Option<CompatLoginSsoAction>) -> Self {
Self {
id,
query: action.map(|action| CompatLoginSsoActionParams { action }),
}
}
}
impl Route for CompatLoginSsoComplete {
type Query = CompatLoginSsoActionParams;
fn query(&self) -> Option<&Self::Query> {
self.query.as_ref()
}
fn route() -> &'static str {
"/complete-compat-sso/:grant_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/complete-compat-sso/{}", self.id).into()
}
}
pub struct UpstreamOAuth2Authorize {
id: Ulid,
post_auth_action: Option<PostAuthAction>,
}
impl UpstreamOAuth2Authorize {
#[must_use]
pub const fn new(id: Ulid) -> Self {
Self {
id,
post_auth_action: None,
}
}
#[must_use]
pub fn and_then(mut self, action: PostAuthAction) -> Self {
self.post_auth_action = Some(action);
self
}
}
impl Route for UpstreamOAuth2Authorize {
type Query = PostAuthAction;
fn route() -> &'static str {
"/upstream/authorize/:provider_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/upstream/authorize/{}", self.id).into()
}
fn query(&self) -> Option<&Self::Query> {
self.post_auth_action.as_ref()
}
}
pub struct UpstreamOAuth2Callback {
id: Ulid,
}
impl UpstreamOAuth2Callback {
#[must_use]
pub const fn new(id: Ulid) -> Self {
Self { id }
}
}
impl Route for UpstreamOAuth2Callback {
type Query = ();
fn route() -> &'static str {
"/upstream/callback/:provider_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/upstream/callback/{}", self.id).into()
}
}
pub struct UpstreamOAuth2Link {
id: Ulid,
}
impl UpstreamOAuth2Link {
#[must_use]
pub const fn new(id: Ulid) -> Self {
Self { id }
}
}
impl Route for UpstreamOAuth2Link {
type Query = ();
fn route() -> &'static str {
"/upstream/link/:link_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/upstream/link/{}", self.id).into()
}
}
#[derive(Default, Serialize, Deserialize, Debug, Clone)]
pub struct DeviceCodeLink {
code: Option<String>,
}
impl DeviceCodeLink {
#[must_use]
pub fn with_code(code: String) -> Self {
Self { code: Some(code) }
}
}
impl Route for DeviceCodeLink {
type Query = DeviceCodeLink;
fn route() -> &'static str {
"/link"
}
fn query(&self) -> Option<&Self::Query> {
Some(self)
}
}
#[derive(Default, Serialize, Deserialize, Debug, Clone)]
pub struct DeviceCodeConsent {
id: Ulid,
}
impl Route for DeviceCodeConsent {
type Query = ();
fn route() -> &'static str {
"/device/:device_code_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/device/{}", self.id).into()
}
}
impl DeviceCodeConsent {
#[must_use]
pub fn new(id: Ulid) -> Self {
Self { id }
}
}
#[derive(Default, Serialize, Deserialize, Debug, Clone)]
pub struct OAuth2DeviceAuthorizationEndpoint;
impl SimpleRoute for OAuth2DeviceAuthorizationEndpoint {
const PATH: &'static str = "/oauth2/device";
}
#[derive(Default, Serialize, Deserialize, Debug, Clone)]
pub struct AccountRecoveryStart;
impl SimpleRoute for AccountRecoveryStart {
const PATH: &'static str = "/recover";
}
#[derive(Default, Serialize, Deserialize, Debug, Clone)]
pub struct AccountRecoveryProgress {
session_id: Ulid,
}
impl AccountRecoveryProgress {
#[must_use]
pub fn new(session_id: Ulid) -> Self {
Self { session_id }
}
}
impl Route for AccountRecoveryProgress {
type Query = ();
fn route() -> &'static str {
"/recover/progress/:session_id"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/recover/progress/{}", self.session_id).into()
}
}
#[derive(Default, Serialize, Deserialize, Debug, Clone)]
pub struct AccountRecoveryFinish {
ticket: String,
}
impl AccountRecoveryFinish {
#[must_use]
pub fn new(ticket: String) -> Self {
Self { ticket }
}
}
impl Route for AccountRecoveryFinish {
type Query = AccountRecoveryFinish;
fn route() -> &'static str {
"/account/password/recovery"
}
fn query(&self) -> Option<&Self::Query> {
Some(self)
}
}
pub struct StaticAsset {
path: String,
}
impl StaticAsset {
#[must_use]
pub fn new(path: String) -> Self {
Self { path }
}
}
impl Route for StaticAsset {
type Query = ();
fn route() -> &'static str {
"/assets/"
}
fn path(&self) -> std::borrow::Cow<'static, str> {
format!("/assets/{}", self.path).into()
}
}
pub struct GraphQL;
impl SimpleRoute for GraphQL {
const PATH: &'static str = "/graphql";
}
pub struct GraphQLPlayground;
impl SimpleRoute for GraphQLPlayground {
const PATH: &'static str = "/graphql/playground";
}
pub struct ApiSpec;
impl SimpleRoute for ApiSpec {
const PATH: &'static str = "/api/spec.json";
}
pub struct ApiDoc;
impl SimpleRoute for ApiDoc {
const PATH: &'static str = "/api/doc/";
}
pub struct ApiDocCallback;
impl SimpleRoute for ApiDocCallback {
const PATH: &'static str = "/api/doc/oauth2-callback";
}