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

use tokio_stream::{Stream, StreamExt};

use crate::grpc::GrpcResult;
use crate::permission::SpiceDBPermissionClient;
use crate::spicedb;
use crate::spicedb::wrappers::{Consistency, ReadRelationshipsResponse};

#[derive(Clone, Debug)]
pub struct ReadRelationshipsRequest {
    client: SpiceDBPermissionClient,
    request: spicedb::ReadRelationshipsRequest,
}

impl ReadRelationshipsRequest {
    pub fn new(client: SpiceDBPermissionClient) -> Self {
        let request = spicedb::ReadRelationshipsRequest {
            ..Default::default()
        };
        ReadRelationshipsRequest { client, request }
    }

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

    pub fn with_cursor(&mut self, cursor: spicedb::Cursor) -> &mut Self {
        self.request.optional_cursor = Some(cursor);
        self
    }

    pub fn with_relationship_filter(&mut self, filter: spicedb::RelationshipFilter) -> &mut Self {
        self.request.relationship_filter = Some(filter);
        self
    }

    pub fn with_consistency(&mut self, consistency: Consistency) -> &mut Self {
        self.request.consistency = Some(consistency.into());
        self
    }

    pub async fn send(
        mut self,
    ) -> GrpcResult<impl Stream<Item = GrpcResult<ReadRelationshipsResponse>>> {
        let resp = self
            .client
            .read_relationships(self.request)
            .await?
            .into_inner();
        Ok(resp.map(|r| r.map(Into::into)))
    }
}