More into_future usage (#663)

* Add nightly only into_future feature

* CreateCollectionBuilder::into_future

* CreateDocument::into_future

* Create permission

* CreateUser::into_future

* DeleteCollection::into_future

* DeleteDatabase::into_future

* DeleteDocument::into_future

* DeletePermission::into_future

* Run format

* Run clippy

* Fix e2e tests

* Fix local tests

Author: rylev

sdk/data_cosmos/Cargo.toml

@@ -43,3 +43,4 @@ stop-token = { version = "0.7.0", features = ["tokio"] }
 [features]
 test_e2e = []
 mock_transport_framework = [ "azure_core/mock_transport_framework"]
+into_future = []

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/create_delete_database.rs

@@ -46,13 +46,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // create collection!
     {
         let db_client = client.clone().into_database_client(database_name.clone());
-
         let create_collection_response = db_client
-            .create_collection(
-                Context::new(),
-                "panzadoro",
-                CreateCollectionOptions::new("/id"),
-            )
+            .create_collection("panzadoro", "/id")
+            .into_future()
             .await?;
 
         println!(
@@ -74,15 +70,14 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
             println!("res == {:#?}", res);
         }
 
-        let delete_response = db_collection
-            .delete_collection(Context::new(), DeleteCollectionOptions::new())
-            .await?;
+        let delete_response = db_collection.delete_collection().into_future().await?;
         println!("collection deleted: {:#?}", delete_response);
     }
 
     let resp = client
         .into_database_client(database_name)
-        .delete_database(Context::new(), DeleteDatabaseOptions::new())
+        .delete_database()
+        .into_future()
         .await?;
     println!("database deleted. resp == {:#?}", resp);
 

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()
     }
 }
 
@@ -102,11 +101,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
             client
                 .clone()
                 .into_database_client(database.id.clone())
-                .create_collection(
-                    Context::new(),
-                    COLLECTION,
-                    CreateCollectionOptions::new("/id"),
-                )
+                .create_collection(COLLECTION, "/id")
+                .into_future()
                 .await?
                 .collection
         }
@@ -118,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(),
     };
@@ -135,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 == {:#?}",
@@ -191,14 +188,16 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         .clone()
         .into_database_client(DATABASE.to_owned())
         .into_collection_client(COLLECTION.to_owned())
-        .delete_collection(Context::new(), DeleteCollectionOptions::new())
+        .delete_collection()
+        .into_future()
         .await?;
     println!("collection deleted");
 
     // And then we delete the database.
     client
         .into_database_client(database.id)
-        .delete_database(Context::new(), DeleteDatabaseOptions::new())
+        .delete_database()
+        .into_future()
         .await?;
     println!("database deleted");
 

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.");
@@ -183,10 +173,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         client
             .clone()
             .into_document_client(id.clone(), &id)?
-            .delete_document(
-                Context::new(),
-                DeleteDocumentOptions::new().consistency_level(&response),
-            )
+            .delete_document()
+            .into_future()
             .await?;
     }
     println!("Cleaned up");

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/permission_00.rs

@@ -58,23 +58,18 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         get_collection2_response
     );
 
-    let create_user_response = user_client
-        .create_user(Context::new(), CreateUserOptions::default())
-        .await?;
+    let create_user_response = user_client.create_user().into_future().await?;
     println!("create_user_response == {:#?}", create_user_response);
 
     // create the first permission!
     let permission_client = user_client.clone().into_permission_client("matrix");
     let permission_mode = get_collection_response.collection.read_permission();
 
     let create_permission_response = permission_client
-        .create_permission(
-            Context::new(),
-            CreatePermissionOptions::new()
-                .consistency_level(&create_user_response)
-                .expiry_seconds(18000u64),
-            &permission_mode,
-        )
+        .create_permission(permission_mode)
+        .consistency_level(&create_user_response)
+        .expiry_seconds(18000u64)
+        .into_future()
         .await
         .unwrap();
     println!(
@@ -87,11 +82,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let permission_mode = get_collection2_response.collection.all_permission();
 
     let create_permission2_response = permission_client
-        .create_permission(
-            Context::new(),
-            CreatePermissionOptions::new().consistency_level(&create_user_response),
-            &permission_mode,
-        )
+        .create_permission(permission_mode)
+        .consistency_level(&create_user_response)
+        .into_future()
         .await
         .unwrap();
 
@@ -145,12 +138,11 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     );
 
     let delete_permission_response = permission_client
-        .delete_permission(
-            Context::new(),
-            DeletePermissionOptions::new().consistency_level(ConsistencyLevel::Session(
-                replace_permission_response.session_token,
-            )),
-        )
+        .delete_permission()
+        .consistency_level(ConsistencyLevel::Session(
+            replace_permission_response.session_token,
+        ))
+        .into_future()
         .await
         .unwrap();