CreateCollectionBuilder::into_future

Author: rylev

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!(

sdk/data_cosmos/examples/document_00.rs

@@ -102,11 +102,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
         }

sdk/data_cosmos/src/clients/database_client.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::operations::*;
+use crate::resources::collection::PartitionKey;
 use crate::resources::ResourceType;
 use crate::ReadonlyString;
 use azure_core::prelude::Continuation;
@@ -154,24 +155,12 @@ impl DatabaseClient {
     }
 
     /// Create a collection
-    pub async fn create_collection<S: AsRef<str>>(
+    pub fn create_collection<S: Into<String>, P: Into<PartitionKey>>(
         &self,
-        ctx: Context,
         collection_name: S,
-        options: CreateCollectionOptions,
-    ) -> crate::Result<CreateCollectionResponse> {
-        let mut request = self.cosmos_client().prepare_request_pipeline(
-            &format!("dbs/{}/colls", self.database_name()),
-            http::Method::POST,
-        );
-
-        options.decorate_request(&mut request, collection_name.as_ref())?;
-        let response = self
-            .pipeline()
-            .send(ctx.clone().insert(ResourceType::Collections), &mut request)
-            .await?;
-
-        Ok(CreateCollectionResponse::try_from(response).await?)
+        partition_key: P,
+    ) -> CreateCollectionBuilder {
+        CreateCollectionBuilder::new(self.clone(), collection_name.into(), partition_key.into())
     }
 
     /// List users
@@ -245,7 +234,7 @@ impl DatabaseClient {
         UserClient::new(self, user_name)
     }
 
-    fn pipeline(&self) -> &Pipeline {
+    pub(crate) fn pipeline(&self) -> &Pipeline {
         self.cosmos_client.pipeline()
     }
 }

sdk/data_cosmos/src/operations/create_collection.rs

@@ -2,24 +2,34 @@ use crate::headers::from_headers::*;
 use crate::prelude::*;
 use crate::resources::collection::{IndexingPolicy, PartitionKey};
 use azure_core::headers::{etag_from_headers, session_token_from_headers};
-use azure_core::{collect_pinned_stream, Request as HttpRequest, Response as HttpResponse};
+use azure_core::{collect_pinned_stream, Context, Response as HttpResponse};
 use chrono::{DateTime, Utc};
 
 #[derive(Debug, Clone)]
-pub struct CreateCollectionOptions {
+pub struct CreateCollectionBuilder {
+    client: DatabaseClient,
     partition_key: PartitionKey,
     consistency_level: Option<ConsistencyLevel>,
     indexing_policy: Option<IndexingPolicy>,
+    collection_name: String,
     offer: Option<Offer>,
+    context: Context,
 }
 
-impl CreateCollectionOptions {
-    pub fn new<P: Into<PartitionKey>>(partition_key: P) -> Self {
+impl CreateCollectionBuilder {
+    pub(crate) fn new(
+        client: DatabaseClient,
+        collection_name: String,
+        partition_key: PartitionKey,
+    ) -> Self {
         Self {
-            partition_key: partition_key.into(),
+            client,
+            collection_name,
+            partition_key,
             consistency_level: None,
             indexing_policy: None,
             offer: None,
+            context: Context::new(),
         }
     }
 
@@ -29,25 +39,49 @@ impl CreateCollectionOptions {
         offer: Offer => Some(offer),
     }
 
-    pub(crate) fn decorate_request(
-        &self,
-        request: &mut HttpRequest,
-        collection_name: &str,
-    ) -> crate::Result<()> {
-        azure_core::headers::add_optional_header2(&self.offer, request)?;
-        azure_core::headers::add_optional_header2(&self.consistency_level, request)?;
+    pub fn into_future(self) -> CreateCollection {
+        Box::pin(async move {
+            let mut request = self.client.cosmos_client().prepare_request_pipeline(
+                &format!("dbs/{}/colls", self.client.database_name()),
+                http::Method::POST,
+            );
+            azure_core::headers::add_optional_header2(&self.offer, &mut request)?;
+            azure_core::headers::add_optional_header2(&self.consistency_level, &mut request)?;
 
-        let collection = CreateCollectionBody {
-            id: collection_name,
-            indexing_policy: &self.indexing_policy,
-            partition_key: &self.partition_key,
-        };
+            let collection = CreateCollectionBody {
+                id: &self.collection_name,
+                indexing_policy: &self.indexing_policy,
+                partition_key: &self.partition_key,
+            };
 
-        request.set_body(bytes::Bytes::from(serde_json::to_string(&collection)?).into());
-        Ok(())
+            request.set_body(bytes::Bytes::from(serde_json::to_string(&collection)?).into());
+
+            let response = self
+                .client
+                .pipeline()
+                .send(
+                    self.context.clone().insert(ResourceType::Collections),
+                    &mut request,
+                )
+                .await?;
+
+            Ok(CreateCollectionResponse::try_from(response).await?)
+        })
     }
 }
 
+#[cfg(feature = "into_future")]
+impl std::future::IntoFuture for CreateCollectionBuilder {
+    type Future = CreateCollection;
+    type Output = <CreateCollection as std::future::Future>::Output;
+    fn into_future(self) -> Self::Future {
+        Self::into_future(self)
+    }
+}
+
+type CreateCollection =
+    futures::future::BoxFuture<'static, crate::Result<CreateCollectionResponse>>;
+
 /// Body for the create collection request
 #[derive(Serialize, Debug)]
 struct CreateCollectionBody<'a> {