spicedb-rust 0.3.4

A client for spicedb
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
115
116
117
118
119
120
121
122
123
124
125
126
127

use self::spicedb::delete_relationships_response::DeletionProgress;
use self::spicedb::precondition::Operation;
use crate::entity::{Relation, Resource};
use crate::permission::SpiceDBPermissionClient;
use crate::spicedb;

#[derive(Debug)]
pub struct DeleteRelationshipsRequest<R>
where
    R: Resource,
{
    client: SpiceDBPermissionClient,
    request: spicedb::DeleteRelationshipsRequest,
    _phantom: std::marker::PhantomData<R>,
}

impl<R> DeleteRelationshipsRequest<R>
where
    R: Resource,
{
    pub fn new(client: SpiceDBPermissionClient) -> Self {
        Self {
            client,
            request: spicedb::DeleteRelationshipsRequest {
                relationship_filter: Some(spicedb::RelationshipFilter {
                    resource_type: R::object_type().into(),
                    ..Default::default()
                }),
                optional_preconditions: vec![],
                optional_limit: 0,
                optional_allow_partial_deletions: false,
            },
            _phantom: std::marker::PhantomData,
        }
    }

    pub fn add_precondition<R2>(
        &mut self,
        operation: Operation,
        resource_id: Option<R2::Id>,
        resource_id_prefix: Option<String>,
        relation: Option<R2::Relations>,
        subject_filter: Option<spicedb::SubjectFilter>,
    ) -> &mut Self
    where
        R2: Resource,
    {
        self.request
            .optional_preconditions
            .push(spicedb::precondition::<R2>(
                operation,
                resource_id,
                resource_id_prefix,
                relation,
                subject_filter,
            ));
        self
    }

    pub fn with_id(&mut self, resource_id: impl Into<R::Id>) -> &mut Self {
        match self.request.relationship_filter.as_mut() {
            Some(rf) => Into::<R::Id>::into(resource_id)
                .into()
                .clone_into(&mut rf.optional_resource_id),
            None => unreachable!(),
        }
        self
    }

    pub fn with_id_prefix(&mut self, id_prefix: impl Into<String>) -> &mut Self {
        match self.request.relationship_filter.as_mut() {
            Some(rf) => id_prefix
                .into()
                .clone_into(&mut rf.optional_resource_id_prefix),
            None => unreachable!(),
        }
        self
    }

    pub fn with_relation(&mut self, relation: R::Relations) -> &mut Self {
        match self.request.relationship_filter.as_mut() {
            Some(rf) => relation.name().clone_into(&mut rf.optional_relation),
            None => unreachable!(),
        }
        self
    }

    pub fn allow_partial_deletions(&mut self) -> &mut Self {
        self.request.optional_allow_partial_deletions = true;
        self
    }

    pub fn limit(&mut self, limit: u32) -> &mut Self {
        self.request.optional_limit = limit;
        self
    }

    pub fn with_subject_filter(&mut self, subject_filter: spicedb::SubjectFilter) -> &mut Self {
        match self.request.relationship_filter.as_mut() {
            Some(rf) => rf.optional_subject_filter = Some(subject_filter),
            None => unreachable!(),
        }
        self
    }

    pub async fn send(
        mut self,
    ) -> Result<
        (
            spicedb::ZedToken,
            spicedb::delete_relationships_response::DeletionProgress,
        ),
        tonic::Status,
    > {
        let resp = self
            .client
            .delete_relationships(self.request)
            .await?
            .into_inner();
        let zed_token = resp
            .deleted_at
            .ok_or_else(|| tonic::Status::internal("Invalid ZedToken"))?;
        let deletion_progress = DeletionProgress::try_from(resp.deletion_progress)
            .map_err(|_| tonic::Status::internal("Invalid i32 value for DeletionProgress"))?;
        Ok((zed_token, deletion_progress))
    }
}