CreateUser::into_future

Author: rylev

sdk/data_cosmos/examples/permission_00.rs

@@ -58,9 +58,7 @@ 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!

sdk/data_cosmos/examples/user_00.rs

@@ -30,7 +30,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let user_client = database_client.clone().into_user_client(user_name.clone());
 
     let create_user_response = user_client
-        .create_user(Context::new(), CreateUserOptions::new())
+        .create_user()
+        .into_future()
         .await?;
     println!("create_user_response == {:#?}", create_user_response);
 

sdk/data_cosmos/examples/user_permission_token.rs

@@ -39,9 +39,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         .await?;
     println!("get_collection_response == {:#?}", get_collection_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);
 
     // test list documents

sdk/data_cosmos/src/clients/user_client.rs

@@ -39,23 +39,8 @@ impl UserClient {
     }
 
     /// Create the user
-    pub async fn create_user(
-        &self,
-        ctx: Context,
-        options: CreateUserOptions,
-    ) -> crate::Result<UserResponse> {
-        let mut request = self.cosmos_client().prepare_request_pipeline(
-            &format!("dbs/{}/users", self.database_client.database_name()),
-            http::Method::POST,
-        );
-
-        options.decorate_request(&mut request, self.user_name())?;
-        let response = self
-            .pipeline()
-            .send(ctx.clone().insert(ResourceType::Users), &mut request)
-            .await?;
-
-        Ok(UserResponse::try_from(response).await?)
+    pub fn create_user(&self) -> CreateUserBuilder {
+        CreateUserBuilder::new(self.clone())
     }
 
     /// Get the user
@@ -137,7 +122,7 @@ impl UserClient {
         self.cosmos_client().http_client()
     }
 
-    fn pipeline(&self) -> &Pipeline {
+    pub(crate) fn pipeline(&self) -> &Pipeline {
         self.cosmos_client().pipeline()
     }
 }

sdk/data_cosmos/src/operations/create_document.rs

@@ -94,6 +94,15 @@ impl<D: Serialize + CosmosEntity + Send + 'static> CreateDocumentBuilder<D> {
 
 type CreateDocument = futures::future::BoxFuture<'static, crate::Result<CreateDocumentResponse>>;
 
+#[cfg(feature = "into_future")]
+impl <D: Serialize + CosmosEntity + Send + 'static> std::future::IntoFuture for CreateDocumentBuilder<D> {
+    type Future = CreateDocument;
+    type Output = <CreateDocument as std::future::Future>::Output;
+    fn into_future(self) -> Self::Future {
+        Self::into_future(self)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct CreateDocumentResponse {
     pub document_attributes: DocumentAttributes,

sdk/data_cosmos/src/operations/create_permission.rs

@@ -72,3 +72,12 @@ impl CreatePermissionBuilder {
 }
 
 type CreatePermission = futures::future::BoxFuture<'static, crate::Result<PermissionResponse>>;
+
+#[cfg(feature = "into_future")]
+impl std::future::IntoFuture for CreatePermissionBuilder {
+    type Future = CreatePermission;
+    type Output = <CreatePermission as std::future::Future>::Output;
+    fn into_future(self) -> Self::Future {
+        Self::into_future(self)
+    }
+}

sdk/data_cosmos/src/operations/create_user.rs

@@ -1,31 +1,63 @@
-use crate::prelude::*;
-use azure_core::Request as HttpRequest;
+use crate::{prelude::*, resources::user::UserResponse};
+use azure_core::Context;
 
-#[derive(Debug, Clone, Default)]
-pub struct CreateUserOptions {
+#[derive(Debug, Clone)]
+pub struct CreateUserBuilder {
+    client: UserClient,
     consistency_level: Option<ConsistencyLevel>,
+    context: Context,
 }
 
-impl CreateUserOptions {
-    pub fn new() -> Self {
+impl CreateUserBuilder {
+    pub(crate) fn new(client: UserClient) -> 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,
-        user_name: &str,
-    ) -> crate::Result<()> {
-        azure_core::headers::add_optional_header2(&self.consistency_level, request)?;
-        let body = CreateUserBody { id: user_name };
-        request.set_body(bytes::Bytes::from(serde_json::to_string(&body)?).into());
-        Ok(())
+    pub fn into_future(self) -> CreateUser {
+        Box::pin(async move {
+            let mut request = self.client.cosmos_client().prepare_request_pipeline(
+                &format!(
+                    "dbs/{}/users",
+                    self.client.database_client().database_name()
+                ),
+                http::Method::POST,
+            );
+
+            azure_core::headers::add_optional_header2(&self.consistency_level, &mut request)?;
+            let body = CreateUserBody {
+                id: self.client.user_name(),
+            };
+            request.set_body(bytes::Bytes::from(serde_json::to_string(&body)?).into());
+            let response = self
+                .client
+                .pipeline()
+                .send(
+                    self.context.clone().insert(ResourceType::Users),
+                    &mut request,
+                )
+                .await?;
+
+            Ok(UserResponse::try_from(response).await?)
+        })
+    }
+}
+
+type CreateUser = futures::future::BoxFuture<'static, crate::Result<UserResponse>>;
+
+#[cfg(feature = "into_future")]
+impl std::future::IntoFuture for CreateUserBuilder {
+    type Future = CreateUser;
+    type Output = <CreateUser as std::future::Future>::Output;
+    fn into_future(self) -> Self::Future {
+        Self::into_future(self)
     }
 }