gatekeep-keepsake 1.0.1

Keepsake relation fact resolver for gatekeep
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

use gatekeep::Context;
use keepsake::{KeepsakeError, SubjectRef};

/// Maps a gatekeep request context to the keepsake subject being resolved.
pub trait SubjectMapper: Send + Sync {
    /// Builds the keepsake subject for this request.
    ///
    /// # Errors
    ///
    /// Returns [`KeepsakeError`] when the mapped subject is invalid.
    fn subject(&self, cx: &Context) -> Result<SubjectRef, KeepsakeError>;
}

/// Default tenant-aware subject mapper.
///
/// It keeps the principal id unchanged and prefixes the principal kind with the
/// tenant id, so equal principal ids in different tenants do not share keepsake
/// relations. Applications with an existing subject convention can provide a
/// custom [`SubjectMapper`] instead.
#[derive(Clone, Copy, Debug, Default)]
pub struct TenantScopedSubjectMapper;

impl SubjectMapper for TenantScopedSubjectMapper {
    fn subject(&self, cx: &Context) -> Result<SubjectRef, KeepsakeError> {
        SubjectRef::new(
            tenant_principal_kind(cx.tenant.as_str(), cx.principal.kind()),
            cx.principal.id(),
        )
    }
}

/// Principal-only subject mapper for applications that already encode tenancy
/// in keepsake subject identifiers.
#[derive(Clone, Copy, Debug, Default)]
pub struct PrincipalSubjectMapper;

impl SubjectMapper for PrincipalSubjectMapper {
    fn subject(&self, cx: &Context) -> Result<SubjectRef, KeepsakeError> {
        SubjectRef::new(cx.principal.kind(), cx.principal.id())
    }
}

/// Maps a gatekeep context through [`TenantScopedSubjectMapper`].
///
/// # Errors
///
/// Returns [`KeepsakeError`] if the mapped subject is invalid.
pub fn tenant_scoped_subject(cx: &Context) -> Result<SubjectRef, KeepsakeError> {
    TenantScopedSubjectMapper.subject(cx)
}

/// Maps a gatekeep context through [`PrincipalSubjectMapper`].
///
/// # Errors
///
/// Returns [`KeepsakeError`] if the mapped subject is invalid.
pub fn principal_subject(cx: &Context) -> Result<SubjectRef, KeepsakeError> {
    PrincipalSubjectMapper.subject(cx)
}

fn tenant_principal_kind(tenant: &str, principal_kind: &str) -> String {
    format!(
        "tenant:{}:{}principal:{}:{}",
        tenant.len(),
        tenant,
        principal_kind.len(),
        principal_kind
    )
}