CreateDocument::into_future

Author: rylev

sdk/data_cosmos/examples/attachments_00.rs

@@ -1,28 +1,21 @@
-use azure_core::Context;
 use azure_data_cosmos::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::borrow::Cow;
 use std::error::Error;
 
-// Now we create a sample struct. The Cow trick
-// allows us to use the same struct for serializing
-// (without having to own the items if not needed) and
-// for deserializing (where owning is required).
-// We do not need to define the "id" field here, it will be
-// specified in the Document struct below.
+// Now we create a sample struct.
 #[derive(Serialize, Deserialize, Clone, Debug)]
-struct MySampleStruct<'a> {
-    id: Cow<'a, str>,
-    a_string: Cow<'a, str>,
+struct MySampleStruct {
+    id: String,
+    a_string: String,
     a_number: u64,
     a_timestamp: i64,
 }
 
-impl<'a> azure_data_cosmos::CosmosEntity<'a> for MySampleStruct<'a> {
-    type Entity = &'a str;
+impl azure_data_cosmos::CosmosEntity for MySampleStruct {
+    type Entity = String;
 
-    fn partition_key(&'a self) -> Self::Entity {
-        self.id.as_ref()
+    fn partition_key(&self) -> Self::Entity {
+        self.id.clone().into()
     }
 }
 
@@ -50,17 +43,14 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let id = format!("unique_id{}", 100);
 
     let doc = MySampleStruct {
-        id: Cow::Borrowed(&id),
-        a_string: Cow::Borrowed("Something here"),
+        id,
+        a_string: "Something here".into(),
         a_number: 100,
         a_timestamp: chrono::Utc::now().timestamp(),
     };
 
     // let's add an entity.
-    match client
-        .create_document(Context::new(), &doc, CreateDocumentOptions::new())
-        .await
-    {
+    match client.create_document(doc.clone()).into_future().await {
         Ok(_) => {
             println!("document created");
         }

sdk/data_cosmos/examples/database_00.rs

@@ -49,12 +49,11 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
                 }"#;
                 let document: Value = serde_json::from_str(data)?;
 
-                let options = CreateDocumentOptions::new()
-                    .is_upsert(true)
-                    .partition_key(&43u32)
-                    .unwrap();
                 let resp = collection_client
-                    .create_document(Context::new(), &document, options)
+                    .create_document(document)
+                    .is_upsert(true)
+                    .partition_key(&43u32)?
+                    .into_future()
                     .await?;
 
                 println!("resp == {:?}", resp);

sdk/data_cosmos/examples/document_00.rs

@@ -4,22 +4,21 @@ use serde::{Deserialize, Serialize};
 // DB.
 use azure_core::prelude::*;
 use azure_data_cosmos::prelude::*;
-use std::borrow::Cow;
 use std::error::Error;
 
 #[derive(Clone, Serialize, Deserialize, Debug)]
-struct MySampleStruct<'a> {
-    id: Cow<'a, str>,
-    a_string: Cow<'a, str>,
+struct MySampleStruct {
+    id: String,
+    a_string: String,
     a_number: u64,
     a_timestamp: i64,
 }
 
-impl<'a> azure_data_cosmos::CosmosEntity<'a> for MySampleStruct<'a> {
-    type Entity = &'a str;
+impl azure_data_cosmos::CosmosEntity for MySampleStruct {
+    type Entity = String;
 
-    fn partition_key(&'a self) -> Self::Entity {
-        self.id.as_ref()
+    fn partition_key(&self) -> Self::Entity {
+        self.id.clone()
     }
 }
 
@@ -115,8 +114,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // data in them. Let's create a Document. The only constraint
     // is that we need an id and an arbitrary, Serializable type.
     let doc = MySampleStruct {
-        id: Cow::Owned("unique_id100".to_owned()),
-        a_string: Cow::Borrowed("Something here"),
+        id: "unique_id100".into(),
+        a_string: "Something here".into(),
         a_number: 100,
         a_timestamp: chrono::Utc::now().timestamp(),
     };
@@ -132,7 +131,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // the document attributes.
 
     let create_document_response = collection_client
-        .create_document(Context::new(), &doc, CreateDocumentOptions::new())
+        .create_document(doc.clone())
+        .into_future()
         .await?;
     println!(
         "create_document_response == {:#?}",

sdk/data_cosmos/examples/document_entries_00.rs

@@ -2,28 +2,22 @@ use azure_core::prelude::*;
 use azure_data_cosmos::prelude::*;
 use futures::stream::StreamExt;
 use serde::{Deserialize, Serialize};
-use std::borrow::Cow;
 use std::error::Error;
 
-// Now we create a sample struct. The Cow trick
-// allows us to use the same struct for serializing
-// (without having to own the items if not needed) and
-// for deserializing (where owning is required).
-// We do not need to define the "id" field here, it will be
-// specified in the Document struct below.
+// Now we create a sample struct.
 #[derive(Serialize, Deserialize, Clone, Debug)]
-struct MySampleStruct<'a> {
-    id: Cow<'a, str>,
-    a_string: Cow<'a, str>,
+struct MySampleStruct {
+    id: String,
+    a_string: String,
     a_number: u64,
     a_timestamp: i64,
 }
 
-impl<'a> azure_data_cosmos::CosmosEntity<'a> for MySampleStruct<'a> {
-    type Entity = &'a str;
+impl azure_data_cosmos::CosmosEntity for MySampleStruct {
+    type Entity = String;
 
-    fn partition_key(&'a self) -> Self::Entity {
-        self.id.as_ref()
+    fn partition_key(&self) -> Self::Entity {
+        self.id.clone()
     }
 }
 
@@ -51,18 +45,14 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let mut response = None;
     for i in 0u64..5 {
         let doc = MySampleStruct {
-            id: Cow::Owned(format!("unique_id{}", i)),
-            a_string: Cow::Borrowed("Something here"),
+            id: format!("unique_id{}", i),
+            a_string: "Something here".into(),
             a_number: i,
             a_timestamp: chrono::Utc::now().timestamp(),
         };
 
         // let's add an entity.
-        response = Some(
-            client
-                .create_document(Context::new(), &doc, CreateDocumentOptions::new())
-                .await?,
-        );
+        response = Some(client.create_document(doc.clone()).into_future().await?);
     }
 
     println!("Created 5 documents.");

sdk/data_cosmos/examples/document_entries_01.rs

@@ -1,22 +1,21 @@
 use azure_core::Context;
 use azure_data_cosmos::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::borrow::Cow;
 use std::error::Error;
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
-struct MySampleStruct<'a> {
-    id: Cow<'a, str>,
-    a_string: Cow<'a, str>,
+struct MySampleStruct {
+    id: String,
+    a_string: String,
     a_number: u64,
     a_timestamp: i64,
 }
 
-impl<'a> azure_data_cosmos::CosmosEntity<'a> for MySampleStruct<'a> {
-    type Entity = &'a str;
+impl azure_data_cosmos::CosmosEntity for MySampleStruct {
+    type Entity = String;
 
-    fn partition_key(&'a self) -> Self::Entity {
-        self.id.as_ref()
+    fn partition_key(&self) -> Self::Entity {
+        self.id.clone()
     }
 }
 
@@ -42,19 +41,17 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let client = client.into_collection_client(collection_name);
 
     let mut doc = MySampleStruct {
-        id: Cow::Owned(format!("unique_id{}", 500)),
-        a_string: Cow::Borrowed("Something here"),
+        id: format!("unique_id{}", 500),
+        a_string: "Something here".into(),
         a_number: 600,
         a_timestamp: chrono::Utc::now().timestamp(),
     };
 
     // let's add an entity.
     let create_document_response = client
-        .create_document(
-            Context::new(),
-            &doc,
-            CreateDocumentOptions::new().is_upsert(true),
-        )
+        .create_document(doc.clone())
+        .is_upsert(true)
+        .into_future()
         .await?;
 
     println!(

sdk/data_cosmos/examples/readme.rs

@@ -3,25 +3,24 @@ use serde::{Deserialize, Serialize};
 // Using the prelude module of the Cosmos crate makes easier to use the Rust Azure SDK for Cosmos.
 use azure_data_cosmos::prelude::*;
 use futures::stream::StreamExt;
-use std::borrow::Cow;
 use std::error::Error;
 
 // This is the stuct we want to use in our sample.
 // Make sure to have a collection with partition key "a_number" for this example to
 // work (you can create with this SDK too, check the examples folder for that task).
-#[derive(Serialize, Deserialize, Debug)]
-struct MySampleStruct<'a> {
-    id: Cow<'a, str>,
-    a_string: Cow<'a, str>,
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct MySampleStruct {
+    id: String,
+    a_string: String,
     a_number: u64,
     a_timestamp: i64,
 }
 
 // Here we mark "a_number" as partition key.
-impl<'a> azure_data_cosmos::CosmosEntity<'a> for MySampleStruct<'a> {
+impl azure_data_cosmos::CosmosEntity for MySampleStruct {
     type Entity = u64;
 
-    fn partition_key(&'a self) -> Self::Entity {
+    fn partition_key(&self) -> Self::Entity {
         self.a_number
     }
 }
@@ -71,20 +70,18 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     for i in 0..10 {
         // define the document.
         let document_to_insert = MySampleStruct {
-            id: Cow::Owned(format!("unique_id{}", i)),
-            a_string: Cow::Borrowed("Something here"),
+            id: format!("unique_id{}", i),
+            a_string: "Something here".into(),
             a_number: i * 100, // this is the partition key
             a_timestamp: chrono::Utc::now().timestamp(),
         };
 
         // insert it and store the returned session token for later use!
         session_token = Some(
             collection_client
-                .create_document(
-                    Context::new(),
-                    &document_to_insert,
-                    CreateDocumentOptions::new().is_upsert(true),
-                )
+                .create_document(document_to_insert.clone())
+                .is_upsert(true)
+                .into_future()
                 .await?
                 .session_token, // get only the session token, if everything else was ok!
         );

sdk/data_cosmos/examples/user_permission_token.rs

@@ -120,14 +120,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         .clone()
         .into_database_client(database_name.clone())
         .into_collection_client(collection_name.clone())
-        .create_document(
-            Context::new(),
-            &document,
-            CreateDocumentOptions::new()
-                .is_upsert(true)
-                .partition_key(&"Gianluigi Bombatomica")
-                .unwrap(),
-        )
+        .create_document(document.clone())
+        .is_upsert(true)
+        .partition_key(&"Gianluigi Bombatomica")?
+        .into_future()
         .await
     {
         Ok(_) => panic!("this should not happen!"),
@@ -169,14 +165,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let create_document_response = client
         .into_database_client(database_name)
         .into_collection_client(collection_name)
-        .create_document(
-            Context::new(),
-            &document,
-            CreateDocumentOptions::new()
-                .is_upsert(true)
-                .partition_key(&"Gianluigi Bombatomica")
-                .unwrap(),
-        )
+        .create_document(document)
+        .is_upsert(true)
+        .partition_key(&"Gianluigi Bombatomica")?
+        .into_future()
         .await?;
     println!(
         "create_document_response == {:#?}",

sdk/data_cosmos/src/clients/collection_client.rs

@@ -101,21 +101,11 @@ impl CollectionClient {
     }
 
     /// create a document in a collection
-    pub async fn create_document<'a, D: Serialize + CosmosEntity<'a>>(
+    pub fn create_document<D: Serialize + CosmosEntity + Send + 'static>(
         &self,
-        ctx: Context,
-        document: &'a D,
-        options: CreateDocumentOptions,
-    ) -> crate::Result<CreateDocumentResponse> {
-        let mut request = self.prepare_doc_request_pipeline(http::Method::POST);
-
-        options.decorate_request(&mut request, document)?;
-        let response = self
-            .pipeline()
-            .send(ctx.clone().insert(ResourceType::Documents), &mut request)
-            .await?;
-
-        Ok(CreateDocumentResponse::try_from(response).await?)
+        document: D,
+    ) -> CreateDocumentBuilder<D> {
+        CreateDocumentBuilder::new(self.clone(), document)
     }
 
     /// query documents in a collection
@@ -191,7 +181,7 @@ impl CollectionClient {
         self.cosmos_client().pipeline()
     }
 
-    fn prepare_doc_request_pipeline(&self, http_method: http::Method) -> Request {
+    pub(crate) fn prepare_doc_request_pipeline(&self, http_method: http::Method) -> Request {
         let path = &format!(
             "dbs/{}/colls/{}/docs",
             self.database_client().database_name(),

sdk/data_cosmos/src/cosmos_entity.rs

@@ -4,18 +4,18 @@ use http::request::Builder;
 use serde::Serialize;
 
 /// CosmosDB partition key. Every CosmosDB entity must implement it.
-pub trait CosmosEntity<'a> {
+pub trait CosmosEntity {
     /// Returned type.
-    type Entity: Serialize + 'a;
+    type Entity: Serialize;
 
     /// Return partition key value as reference.
-    fn partition_key(&'a self) -> Self::Entity;
+    fn partition_key(&self) -> Self::Entity;
 }
 
-impl<'a> CosmosEntity<'a> for serde_json::Value {
-    type Entity = &'a Self;
-    fn partition_key(&'a self) -> Self::Entity {
-        self
+impl CosmosEntity for serde_json::Value {
+    type Entity = Self;
+    fn partition_key(&self) -> Self::Entity {
+        self.clone()
     }
 }