DeleteCollection::into_future

Author: rylev

sdk/data_cosmos/examples/create_delete_database.rs

@@ -70,9 +70,7 @@ 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);
     }
 

sdk/data_cosmos/examples/document_00.rs

@@ -188,7 +188,8 @@ 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");
 

sdk/data_cosmos/src/clients/collection_client.rs

@@ -60,21 +60,8 @@ impl CollectionClient {
     }
 
     /// Delete a collection
-    pub async fn delete_collection(
-        &self,
-        ctx: Context,
-        options: DeleteCollectionOptions,
-    ) -> crate::Result<DeleteCollectionResponse> {
-        let mut request = self.prepare_request_with_collection_name(http::Method::DELETE);
-
-        options.decorate_request(&mut request)?;
-
-        let response = self
-            .pipeline()
-            .send(ctx.clone().insert(ResourceType::Collections), &mut request)
-            .await?;
-
-        Ok(DeleteCollectionResponse::try_from(response).await?)
+    pub fn delete_collection(&self) -> DeleteCollectionBuilder {
+        DeleteCollectionBuilder::new(self.clone())
     }
 
     /// Replace a collection
@@ -163,7 +150,10 @@ impl CollectionClient {
         StoredProcedureClient::new(self, stored_procedure_name)
     }
 
-    fn prepare_request_with_collection_name(&self, http_method: http::Method) -> Request {
+    pub(crate) fn prepare_request_with_collection_name(
+        &self,
+        http_method: http::Method,
+    ) -> Request {
         let path = &format!(
             "dbs/{}/colls/{}",
             self.database_client().database_name(),

sdk/data_cosmos/src/operations/delete_collection.rs

@@ -1,29 +1,60 @@
 use crate::prelude::*;
 use crate::{headers::from_headers::*, ResourceQuota};
 use azure_core::headers::{content_type_from_headers, session_token_from_headers};
-use azure_core::{Request as HttpRequest, Response as HttpResponse};
+use azure_core::{Context, Response as HttpResponse};
 use chrono::{DateTime, Utc};
 
 #[derive(Debug, Clone)]
-pub struct DeleteCollectionOptions {
+pub struct DeleteCollectionBuilder {
+    client: CollectionClient,
     consistency_level: Option<ConsistencyLevel>,
+    context: Context,
 }
 
-impl DeleteCollectionOptions {
-    pub fn new() -> Self {
+impl DeleteCollectionBuilder {
+    pub fn new(client: CollectionClient) -> Self {
         Self {
+            client,
             consistency_level: None,
+            context: Context::new(),
         }
     }
 
     setters! {
         consistency_level: ConsistencyLevel => Some(consistency_level),
     }
 
-    pub(crate) fn decorate_request(&self, request: &mut HttpRequest) -> crate::Result<()> {
-        azure_core::headers::add_optional_header2(&self.consistency_level, request)?;
+    pub fn into_future(self) -> DeleteCollection {
+        Box::pin(async move {
+            let mut request = self
+                .client
+                .prepare_request_with_collection_name(http::Method::DELETE);
 
-        Ok(())
+            azure_core::headers::add_optional_header2(&self.consistency_level, &mut request)?;
+
+            let response = self
+                .client
+                .pipeline()
+                .send(
+                    self.context.clone().insert(ResourceType::Collections),
+                    &mut request,
+                )
+                .await?;
+
+            Ok(DeleteCollectionResponse::try_from(response).await?)
+        })
+    }
+}
+
+type DeleteCollection =
+    futures::future::BoxFuture<'static, crate::Result<DeleteCollectionResponse>>;
+
+#[cfg(feature = "into_future")]
+impl std::future::IntoFuture for DeleteCollectionBuilder {
+    type Future = DeleteCollection;
+    type Output = <DeleteCollection as std::future::Future>::Output;
+    fn into_future(self) -> Self::Future {
+        Self::into_future(self)
     }
 }