better-auth-api 1.0.0-alpha.5

Plugin implementations for better-auth
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use super::{AddMemberInput, EndpointContext, OrganizationPlugin};
use better_auth_core::endpoint_input::ValidatedBody;
use better_auth_core::{
    AuthContext, AuthError, AuthRecordFields, AuthRequest, AuthResponse, AuthResult, AuthRoute,
    AuthSchema, FieldValue, FromFieldMap, HttpMethod, NativeRequest,
};
use serde_json::Value;

enum MemberInput {
    Json(Option<Value>),
    Native(FieldValue),
}

/// The registered pathless organization endpoint and its captured configuration.
pub struct OrganizationApi<'a, S: AuthSchema> {
    plugin: OrganizationPlugin,
    context: &'a AuthContext<S>,
    source: NativeRequest<'a>,
    transaction: Option<&'a dyn better_auth_core::store::AuthTransaction<S>>,
}

impl<'a, S: AuthSchema> OrganizationApi<'a, S> {
    /// Bind the organization configuration installed on this auth instance.
    pub fn from_context(context: &'a AuthContext<S>) -> AuthResult<Self> {
        let plugin = context
            .extensions
            .get::<OrganizationPlugin>()
            .ok_or_else(|| AuthError::config("OrganizationPlugin is not registered"))?;
        Ok(Self::with_plugin(plugin.clone(), context))
    }

    pub(super) fn with_plugin(plugin: OrganizationPlugin, context: &'a AuthContext<S>) -> Self {
        Self {
            plugin,
            context,
            source: NativeRequest::default(),
            transaction: None,
        }
    }

    /// Keep the resolved runtime and the active database transaction.
    pub fn from_endpoint(endpoint: &EndpointContext<'a, S>) -> AuthResult<Self> {
        let mut api = Self::from_context(endpoint.auth)?;
        api.transaction = endpoint.transaction;
        Ok(api)
    }

    /// Supply native Request and headers independently without importing ambient HTTP input.
    pub fn with_request(mut self, source: NativeRequest<'a>) -> Self {
        self.source = source;
        self
    }

    /// Add a member through global hooks, configured validation, and organization lifecycle hooks.
    /// The result retains endpoint after-hook replacements.
    pub async fn add_member(&self, body: Option<Value>) -> AuthResult<Value> {
        self.add_member_response(MemberInput::Json(body))
            .await?
            .body
            .json()?
            .ok_or_else(|| AuthError::internal("Native addMember returned undefined"))
    }

    pub(super) async fn add_member_value(&self, body: FieldValue) -> AuthResult<FieldValue> {
        self.add_member_response(MemberInput::Native(body))
            .await?
            .body
            .field_value()
    }

    async fn add_member_response(&self, body: MemberInput) -> AuthResult<AuthResponse> {
        let schema = self.plugin.config.schema.member.clone();
        let route = AuthRoute::server_only(HttpMethod::Post, "addMember")
            .body_validator(move |request| validate(request, &schema));
        let handler = |request: AuthRequest, context: std::sync::Arc<AuthContext<S>>| async move {
            let input = request
                .validated_body::<AddMemberInput>()
                .ok_or_else(|| AuthError::internal("Missing validated member input"))?;
            let mut endpoint = EndpointContext::native(
                Some(&request),
                request.original_request(),
                request.input_field_value()?,
                &context,
            );
            endpoint.transaction = self.transaction;
            let member = self
                .plugin
                .add_member_core(input.clone(), &request, &endpoint)
                .await?;
            Ok(AuthResponse::native(None, member.field_values()?.into()))
        };
        match body {
            MemberInput::Json(body) => {
                self.context
                    .dispatch_native(self.source, route, body, None, handler)
                    .await
            }
            MemberInput::Native(body) => {
                self.context
                    .dispatch_native_value(self.source, route, body, FieldValue::Undefined, handler)
                    .await
            }
        }
    }
}

pub(super) fn validate(
    request: &AuthRequest,
    schema: &better_auth_core::user_fields::UserConfig,
) -> AuthResult<ValidatedBody> {
    use super::super::input::{self, BaseField};
    let raw = request.input_field_value()?;
    let mut errors = Vec::new();
    let Some(object) = raw.as_object() else {
        return Err(AuthError::RequestValidation {
            message: input::native_invalid_type("body", "object", Some(&raw)),
        });
    };
    let body = input::native_fields(
        schema,
        &object.snapshot_fields()?,
        &[
            ("userId", BaseField::CoercedString, true),
            ("role", BaseField::Roles, true),
            ("organizationId", BaseField::String, false),
            ("teamId", BaseField::String, false),
        ],
        "body",
        false,
        false,
        &mut errors,
    )?;
    input::finish(errors)?;
    Ok(ValidatedBody::native(
        body.clone().into(),
        AddMemberInput::from_field_values(body)?,
    ))
}