Struct cipherstash_client::stash::Stash

pub struct Stash<Client, Data> { /* private fields */ }

The interface between the client and the data service.

This struct manages encrypting and decrypting records and metadata, encrypting queries and inserting and retrieving records.

It communicates with the data service through a gRPC client.

Implementations

impl Stash<Channel, NativeClientData>

pub fn try_from_config(config: &Config) -> Result<Self, CreateClientError>

Try and create a native client from a resolved Config

impl<Client, Data> Stash<Client, Data>where
    Client: GrpcService<BoxBody>,
    Client::ResponseBody: Body + Send + 'static,
    Client::Error: Into<StdError>,
    <Client::ResponseBody as Body>::Error: Into<StdError> + Send,
    Data: GetAccessToken + GetCipherEngine,

pub fn new(client: Client, data: Data) -> Self

Create a new Stash instance from a gRPC client, encryption key provider and access token provider.

pub async fn delete_collection(
    &mut self,
    collection_ref: &[u8]
) -> Result<(), DeleteCollectionError>

pub async fn list_collections(
    &mut self
) -> Result<ListCollectionsResponse, ListCollectionsError>

pub async fn get_all(
    &mut self,
    collection: &Collection,
    ids: Vec<Uuid>
) -> Result<Vec<Record>, GetAllError>

pub async fn delete_record(
    &mut self,
    collection: &Collection,
    id: Uuid
) -> Result<(), DeleteRecordError>

pub async fn put_record(
    &mut self,
    collection: &mut Collection,
    record: &Record
) -> Result<(), PutRecordError>

pub async fn put_all(
    &mut self,
    collection: &mut Collection,
    records: impl IntoIterator<Item = Record> + 'static
) -> Result<usize, PutStreamError>

pub async fn put_stream(
    &mut self,
    collection: &mut Collection,
    record_stream: impl Stream<Item = Record> + 'static
) -> Result<usize, PutStreamError>

pub async fn get_record(
    &mut self,
    collection: &Collection,
    id: Uuid
) -> Result<Option<Record>, GetRecordError>

pub async fn query(
    &mut self,
    collection: &mut Collection,
    query: QueryInput
) -> Result<QueryResponse, QueryError>

impl<Client, Data> Stash<Client, Data>where
    Client: GrpcService<BoxBody>,
    Client::ResponseBody: Body + Send + 'static,
    Client::Error: Into<StdError>,
    <Client::ResponseBody as Body>::Error: Into<StdError> + Send,
    Data: GetAccessToken + GetCipherEngine + GetNamingKey,

pub async fn collection_info(
    &mut self,
    name: String
) -> Result<CollectionDecryptResult, CollectionInfoError>

pub async fn create_collection(
    &mut self,
    name: String,
    schema: RecordSchema,
    indexes: impl IntoIterator<Item = (String, Mapping)>
) -> Result<Collection, CreateCollectionError>