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

use super::*;
use better_auth_core::FromFieldMap;

pub(super) async fn capture(scenario: &Json) -> AuthResult<Json> {
    let identifier = "trust-device-native";
    let harness = Harness::new(scenario, identifier)?;
    let plugin = TwoFactorPlugin::new();
    let (context, inner) = harness.context(&[&plugin]).await?;
    let session = FieldMap::from([
        ("id".into(), "new-session-id".into()),
        ("token".into(), "new-session".into()),
        ("userId".into(), "owner".into()),
        ("createdAt".into(), date(NOW as f64)),
        ("updatedAt".into(), date(NOW as f64)),
        ("expiresAt".into(), date((NOW + 60_000) as f64)),
        ("ipAddress".into(), FieldValue::Null),
        ("userAgent".into(), FieldValue::Null),
    ]);
    let user = FieldValue::from(consumer_user());
    let new_session = FieldValue::from(FieldMap::from([
        ("user".into(), user.clone()),
        ("session".into(), session.clone().into()),
    ]));
    harness
        .cache
        .insert("new-session", new_session.stringify()?.unwrap().into())?;
    let active = FieldValue::from(vec![FieldValue::from(FieldMap::from([
        ("token".into(), "new-session".into()),
        ("expiresAt".into(), (NOW + 60_000).into()),
    ]))]);
    harness
        .cache
        .insert("active-sessions-owner", active.stringify()?.unwrap().into())?;
    let mut request = AuthRequest::new(HttpMethod::Post, "/sign-in/email");
    let token = sign_value(SECRET, &format!("owner!{identifier}"))?;
    request_cookie(
        &mut request,
        &context,
        TRUST_DEVICE_COOKIE_SUFFIX,
        &format!("{token}!{identifier}"),
    )?;
    context.session_manager().publish_session(
        &request,
        NativeSessionData::new(
            better_auth_core::SessionView::from_field_values(session)?,
            user.clone(),
        ),
    )?;
    let mut response = AuthResponse::native(None, FieldValue::Undefined);
    let before = harness.state(&inner)?;
    harness.activate();
    let harness = &harness;
    let result = context
        .with_native_context(
            better_auth_core::NativeRequest::default(),
            |context| async move {
                let result = plugin
                    .after_request(&request, &mut response, &context)
                    .await;
                let snapshot = request.new_session()?.unwrap();
                assert!(
                    snapshot.user_value()?.strict_equals(&user),
                    "The failure must retain the issued User identity"
                );
                let current = FieldValue::from(FieldMap::from([
                    ("user".into(), snapshot.user_value()?),
                    ("session".into(), snapshot.session_value()?),
                ]));
                let context_headers = request.take_response_headers()?;
                harness.record(
                    "consumer:trust-finally",
                    [
                        ("newSession".into(), harness.observe(&current)?),
                        ("headers".into(), headers(&response.headers)),
                        ("cookies".into(), cookies(&response.headers)),
                        ("contextHeaders".into(), headers(&context_headers)),
                    ],
                );
                result.map(|()| FieldValue::Undefined)
            },
        )
        .await;
    harness.finish(before, harness.outcome(result)?, &inner)
}