Struct ExperimentalServiceClient

pub struct ExperimentalServiceClient<T> { /* private fields */ }

ExperimentalService exposes a number of APIs that are currently being prototyped and tested for future inclusion in the stable API.

Implementations

impl ExperimentalServiceClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>

where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> ExperimentalServiceClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> ExperimentalServiceClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn bulk_import_relationships( &mut self, request: impl IntoStreamingRequest<Message = BulkImportRelationshipsRequest>, ) -> Result<Response<BulkImportRelationshipsResponse>, Status>

BulkImportRelationships is a faster path to writing a large number of relationships at once. It is both batched and streaming. For maximum performance, the caller should attempt to write relationships in as close to relationship sort order as possible: (resource.object_type, resource.object_id, relation, subject.object.object_type, subject.object.object_id, subject.optional_relation)

EXPERIMENTAL https://github.com/authzed/spicedb/issues/1303

pub async fn bulk_export_relationships( &mut self, request: impl IntoRequest<BulkExportRelationshipsRequest>, ) -> Result<Response<Streaming<BulkExportRelationshipsResponse>>, Status>

BulkExportRelationships is the fastest path available to exporting relationships from the server. It is resumable, and will return results in an order determined by the server.

pub async fn bulk_check_permission( &mut self, request: impl IntoRequest<BulkCheckPermissionRequest>, ) -> Result<Response<BulkCheckPermissionResponse>, Status>

NOTE: BulkCheckPermission has been promoted to the stable API as “CheckBulkPermission” and the API will be removed from experimental in a future release.

pub async fn experimental_reflect_schema( &mut self, request: impl IntoRequest<ExperimentalReflectSchemaRequest>, ) -> Result<Response<ExperimentalReflectSchemaResponse>, Status>

EXPERIMENTAL: ReflectSchema is an API that allows clients to reflect the schema stored in SpiceDB. This is useful for clients that need to introspect the schema of a SpiceDB instance.

pub async fn experimental_computable_permissions( &mut self, request: impl IntoRequest<ExperimentalComputablePermissionsRequest>, ) -> Result<Response<ExperimentalComputablePermissionsResponse>, Status>

EXPERIMENTAL: ComputablePermissions is an API that allows clients to request the set of permissions that compute based off a relation. For example, if a schema has a relation viewer and a permission view defined as permission view = viewer + editor, then the computable permissions for the relation viewer will include view.

pub async fn experimental_dependent_relations( &mut self, request: impl IntoRequest<ExperimentalDependentRelationsRequest>, ) -> Result<Response<ExperimentalDependentRelationsResponse>, Status>

EXPERIMENTAL: DependentRelations is an API that allows clients to request the set of relations and permissions that used to compute a permission, recursively. It is the inverse of the ComputablePermissions API.

pub async fn experimental_diff_schema( &mut self, request: impl IntoRequest<ExperimentalDiffSchemaRequest>, ) -> Result<Response<ExperimentalDiffSchemaResponse>, Status>

EXPERIMENTAL: DiffSchema is an API that allows clients to request the difference between the specified schema and the schema stored in SpiceDB. This is useful for clients that need to introspect the schema of a SpiceDB instance.

pub async fn experimental_register_relationship_counter( &mut self, request: impl IntoRequest<ExperimentalRegisterRelationshipCounterRequest>, ) -> Result<Response<ExperimentalRegisterRelationshipCounterResponse>, Status>

EXPERIMENTAL: RegisterRelationshipCounter registers a new filter for counting relationships. A filter must be registered before a count can be requested.

pub async fn experimental_count_relationships( &mut self, request: impl IntoRequest<ExperimentalCountRelationshipsRequest>, ) -> Result<Response<ExperimentalCountRelationshipsResponse>, Status>

EXPERIMENTAL: CountRelationships returns the count of relationships for pre-registered filter.

pub async fn experimental_unregister_relationship_counter( &mut self, request: impl IntoRequest<ExperimentalUnregisterRelationshipCounterRequest>, ) -> Result<Response<ExperimentalUnregisterRelationshipCounterResponse>, Status>

EXPERIMENTAL: UnregisterRelationshipCounter unregisters an existing filter for counting relationships.

Trait Implementations

impl<T: Clone> Clone for ExperimentalServiceClient<T>

fn clone(&self) -> ExperimentalServiceClient<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ExperimentalServiceClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.