firestore-grpc

Firestore client library for Rust. If you use Cloud Run, please use https://github.com/gkkachi/firestore-grpc-cloudrun instead, which provides some useful functions such as get_client(), get_project_id().

Example

This example is experimental. In a real situation, you need to implement features such as token updates.

Environment variables

shell export PROJECT_ID=YOUR_PROJECT_ID export TOKEN=`gcloud auth print-access-token`

Code

Cargo.toml

toml [dependencies] firestore_grpc = "0.31" tokio = {version = "0.2", features = ["full"]}

main.rs

```rust use firestoregrpc::tonic::{ metadata::MetadataValue, transport::{Channel, ClientTlsConfig}, Request, }; use firestoregrpc::v1::{ firestore_client::FirestoreClient, value::ValueType, CreateDocumentRequest, Document, Value, }; use std::env;

const URL: &'static str = "https://firestore.googleapis.com"; const DOMAIN: &'static str = "firestore.googleapis.com";

pub type BoxError = Box;

fn get_token() -> String { env::var("TOKEN").unwrap() }

fn getprojectid() -> String { env::var("PROJECT_ID").unwrap() }

async fn getclient() -> Result, BoxError> { let endpoint = Channel::fromstatic(URL).tlsconfig(ClientTlsConfig::new().domainname(DOMAIN));

let bearer_token = format!("Bearer {}", get_token());
let header_value = MetadataValue::from_str(&bearer_token)?;

let channel = endpoint.connect().await?;

let service = FirestoreClient::with_interceptor(channel, move |mut req: Request<()>| {
    req.metadata_mut()
        .insert("authorization", header_value.clone());
    Ok(req)
});
Ok(service)

}

async fn createdocument() -> Result { let parent = format!( "projects/{}/databases/(default)/documents", getprojectid() ); let collectionid = "greetings".into(); let documentid = "".into(); let mut fields = std::collections::HashMap::new(); fields.insert( "message".into(), Value { valuetype: Some(ValueType::StringValue("Hello world!".into())), }, ); let document = Some(Document { name: "".into(), fields, createtime: None, updatetime: None, }); let res = getclient() .await? .createdocument(CreateDocumentRequest { parent, collectionid, documentid, document, mask: None, }) .await?; Ok(res.into_inner()) }

[tokio::main]

async fn main() { create_document().await.unwrap(); } ```