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

use super::*;
use crate::plugins::organization::OrganizationPlugin;
use crate::plugins::test_helpers::{
    assert_coded_api_error, create_test_config, create_test_context_with_plugins,
    create_user_and_session,
};
use better_auth_core::{CreateMember, CreateOrganization, CreateUser};
use chrono::Duration;

#[tokio::test]
async fn resend_renews_existing_invitation_when_pending_limit_is_reached() {
    let config = OrganizationConfig {
        invitation_limit: Some(1),
        ..Default::default()
    };
    let ctx = create_test_context_with_plugins(
        create_test_config(),
        &[&OrganizationPlugin::with_config(config.clone())],
    )
    .await;
    let (user, session) = create_user_and_session(
        &ctx,
        CreateUser {
            name: Some("Fixture".into()).into(),
            email: Some("owner@example.com".into()),
            ..Default::default()
        },
        Duration::hours(1),
    )
    .await;
    let organization = ctx
        .database
        .create_organization(CreateOrganization {
            additional_fields: Default::default(),
            id: None,
            name: "Organization".into(),
            slug: "resend-limit".into(),
            logo: None.into(),
            metadata: None.into(),
        })
        .await
        .unwrap();
    ctx.database
        .create_member(CreateMember {
            additional_fields: Default::default(),
            organization_id: organization.id.typed().unwrap().clone().into(),
            user_id: user.id.clone(),
            role: "owner".into(),
        })
        .await
        .unwrap();
    let mut body: InviteMemberRequest = serde_json::from_value(serde_json::json!({
        "organizationId": organization.id, "email": "invitee@example.com", "role": "member",
    }))
    .unwrap();
    let first = invite_member_core(
        &body,
        &(user.clone(), session.clone()).into(),
        &config,
        &ctx,
        None,
    )
    .await
    .unwrap();
    let shortened = first
        .expires_at
        .typed()
        .unwrap()
        .to_datetime()
        .unwrap()
        .unwrap()
        - Duration::hours(1);
    ctx.database
        .update_invitation_expiry(first.id.typed().unwrap(), shortened)
        .await
        .unwrap();
    body.resend = true.into();
    let resent = invite_member_core(
        &body,
        &(user.clone(), session.clone()).into(),
        &config,
        &ctx,
        None,
    )
    .await
    .unwrap();
    assert_eq!(resent.id, first.id);
    assert!(
        resent
            .expires_at
            .typed()
            .unwrap()
            .to_datetime()
            .unwrap()
            .unwrap()
            > shortened
    );
    assert_eq!(
        ctx.database
            .get_invitation_by_id(first.id.typed().unwrap())
            .await
            .unwrap()
            .unwrap()
            .expires_at,
        resent.expires_at
    );
    body.email = "another@example.com".into();
    let error = invite_member_core(
        &body,
        &(user.clone(), session.clone()).into(),
        &config,
        &ctx,
        None,
    )
    .await
    .unwrap_err();
    assert_coded_api_error(
        &error,
        "FORBIDDEN",
        403,
        "INVITATION_LIMIT_REACHED",
        "Invitation limit reached",
    );
}