alibi-core 0.3.0

Shared authentication contracts and backend-independent services for Alibi
Documentation 
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

use crate::store::OrganizationStore;
use crate::store::stateless::StatelessStore;
use crate::{AuthError, AuthResult, CreateOrganization, Organization, UpdateOrganization};
use async_trait::async_trait;
use chrono::Utc;

fn patch(row: &mut Organization, update: UpdateOrganization) {
    if let Some(name) = update.name {
        row.name = name;
    }
    if let Some(slug) = update.slug {
        row.slug = slug;
    }
    if let Some(logo) = update.logo {
        row.logo = logo;
    }
    if let Some(metadata) = update.metadata {
        row.metadata = Some(metadata);
    }
}

#[async_trait]
impl OrganizationStore for StatelessStore {
    async fn create_organization(&self, data: CreateOrganization) -> AuthResult<Organization> {
        let now = Utc::now();
        let row = Organization {
            additional_fields: std::collections::BTreeMap::default(),
            id: data.id.unwrap_or_else(|| uuid::Uuid::new_v4().to_string()),
            name: data.name,
            slug: data.slug,
            logo: data.logo,
            metadata: data.metadata,
            created_at: now,
            updated_at: now,
        };
        _ = self
            .organization_state()?
            .organizations
            .insert(row.id.clone(), row.clone());
        Ok(row)
    }
    async fn get_organization_by_id(&self, id: &str) -> AuthResult<Option<Organization>> {
        Ok(self.organization_state()?.organizations.get(id).cloned())
    }
    async fn get_organization_by_slug(&self, slug: &str) -> AuthResult<Option<Organization>> {
        Ok(self
            .organization_state()?
            .organizations
            .values()
            .find(|row| row.slug == slug)
            .cloned())
    }
    async fn list_organizations_by_ids(&self, ids: &[String]) -> AuthResult<Vec<Organization>> {
        Ok(self
            .organization_state()?
            .organizations
            .values()
            .filter(|row| ids.contains(&row.id))
            .cloned()
            .collect())
    }
    async fn update_organization(
        &self,
        id: &str,
        update: UpdateOrganization,
    ) -> AuthResult<Organization> {
        self.update_organization_if_present(id, update)
            .await?
            .ok_or_else(|| AuthError::not_found("Organization not found"))
    }
    async fn patch_organization_if_present(
        &self,
        id: &str,
        update: UpdateOrganization,
    ) -> AuthResult<Option<Organization>> {
        let mut state = self.organization_state()?;
        let Some(row) = state.organizations.get_mut(id) else {
            return Ok(None);
        };
        // Memory adapter Object.assign accepts an empty patch. No synthesized timestamp.
        patch(row, update);
        Ok(Some(row.clone()))
    }
    async fn update_organization_if_present(
        &self,
        id: &str,
        update: UpdateOrganization,
    ) -> AuthResult<Option<Organization>> {
        let mut state = self.organization_state()?;
        let Some(row) = state.organizations.get_mut(id) else {
            return Ok(None);
        };
        patch(row, update);
        row.updated_at = Utc::now();
        Ok(Some(row.clone()))
    }
    async fn delete_organization(&self, id: &str) -> AuthResult<()> {
        let mut state = self.organization_state()?;
        state.members.retain(|_, row| row.organization_id != id);
        state.invitations.retain(|_, row| row.organization_id != id);
        _ = state.organizations.shift_remove(id);
        Ok(())
    }
    async fn list_user_organizations(&self, user_id: &str) -> AuthResult<Vec<Organization>> {
        let state = self.organization_state()?;
        Ok(state
            .members
            .values()
            .filter(|row| row.user_id == user_id)
            .take(self.find_many_limit)
            .filter_map(|row| state.organizations.get(&row.organization_id).cloned())
            .collect())
    }
}