Struct SsoOptions 

pub struct SsoOptions {

    pub model_name: String,
    pub provider_table: String,
    pub providers_limit: usize,
    pub providers_limit_callback: Option<ProvidersLimitResolver>,
    pub domain_verification: DomainVerificationOptions,
    pub redirect_uri: Option<String>,
    pub disable_implicit_sign_up: bool,
    pub trust_email_verified: bool,
    pub default_override_user_info: bool,
    pub oidc: OidcOptions,
    pub provision_user: Option<ProvisionUserResolver>,
    pub provision_user_on_every_login: bool,
    pub organization_provisioning: OrganizationProvisioningOptions,
    pub saml: SamlOptions,
    pub rate_limit: SsoRateLimitOptions,
    pub audit_event: Option<SsoAuditEventResolver>,
    pub default_sso: Vec<SsoProvider>,
}

Configuration for the RustAuth SSO plugin.

Fields

model_name: String

Logical schema model name contributed by the plugin.

provider_table: String

Physical database table name for SSO providers.

providers_limit: usize

Static maximum number of providers a user may register.

providers_limit_callback: Option<ProvidersLimitResolver>

Optional dynamic provider limit resolver.

domain_verification: DomainVerificationOptions

Domain verification settings.

redirect_uri: Option<String>

Shared OIDC redirect URI override.

disable_implicit_sign_up: bool

Disable implicit user creation during SSO login.

trust_email_verified: bool

Trust IdP email verification for implicit account linking.

default_override_user_info: bool

Default value for provider-level user info override behavior.

oidc: OidcOptions

OIDC runtime and security settings.

provision_user: Option<ProvisionUserResolver>

Optional hook for application-specific user provisioning.

provision_user_on_every_login: bool

Run provision_user for existing users on every login.

organization_provisioning: OrganizationProvisioningOptions

Organization provisioning settings.

saml: SamlOptions

SAML runtime and security settings.

rate_limit: SsoRateLimitOptions

Plugin rate limit settings.

audit_event: Option<SsoAuditEventResolver>

Optional audit event sink.

default_sso: Vec<SsoProvider>

Statically configured SSO providers.

Implementations

impl SsoOptions

pub fn new() -> Self

Create default SSO plugin options.

pub fn provider_table(self, table: impl Into<String>) -> Self

Override the physical provider table name.

pub fn providers_limit(self, limit: usize) -> Self

Set the static maximum provider count per user.

pub fn providers_limit_callback<F, Fut>(self, resolver: F) -> Self

where F: Fn(User) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<usize, RustAuthError>> + Send + 'static,

Set a dynamic provider limit callback.

pub async fn resolve_providers_limit( &self, user: User, ) -> Result<usize, RustAuthError>

Resolve the effective provider limit for a user.

pub fn domain_verification_enabled(self, enabled: bool) -> Self

Enable or disable DNS domain verification.

pub fn domain_txt_resolver<F, Fut>(self, resolver: F) -> Self

where F: Fn(String) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Vec<String>, RustAuthError>> + Send + 'static,

Set a custom DNS TXT resolver for domain verification.

pub fn redirect_uri(self, redirect_uri: impl Into<String>) -> Self

Override the OIDC redirect URI used in authorization requests.

pub fn organization_provisioning( self, provisioning: OrganizationProvisioningOptions, ) -> Self

Configure organization provisioning.

pub fn provision_user<F, Fut>(self, resolver: F) -> Self

where F: Fn(ProvisionUserInput) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), RustAuthError>> + Send + 'static,

Set a user provisioning hook.

pub fn provision_user_on_every_login(self, enabled: bool) -> Self

Run the provisioning hook for existing users on every login.

pub fn rate_limit(self, rate_limit: SsoRateLimitOptions) -> Self

Replace all SSO rate limit settings.

pub fn rate_limit_enabled(self, enabled: bool) -> Self

Enable or disable SSO rate limit rule contributions.

pub fn audit_event<F, Fut>(self, resolver: F) -> Self

where F: Fn(SsoAuditEvent) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Set an async audit event sink.

pub fn strict_oidc_manual_endpoint_origins(self, enabled: bool) -> Self

Require manually configured OIDC endpoints to match trusted origins.

pub fn allow_private_endpoint_ips(self, enabled: bool) -> Self

Allow OIDC outbound requests to resolve to private or internal IPs.

Leave disabled (the default) to keep SSRF protection active. Enable only when identity providers are intentionally hosted on a private network.

Trait Implementations

impl Clone for SsoOptions

fn clone(&self) -> SsoOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SsoOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SsoOptions

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SsoOptions

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SsoOptions

impl PartialEq for SsoOptions

fn eq(&self, other: &SsoOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SsoOptions

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SsoOptions