Create permission

Author: rylev

sdk/data_cosmos/examples/permission_00.rs

@@ -68,13 +68,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     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 +84,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();
 

sdk/data_cosmos/examples/user_permission_token.rs

@@ -61,11 +61,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let permission_mode = get_collection_response.collection.read_permission();
 
     let create_permission_response = permission_client
-        .create_permission(
-            Context::new(),
-            CreatePermissionOptions::new().expiry_seconds(18000u64), // 5 hours, max!
-            &permission_mode,
-        )
+        .create_permission(permission_mode)
+        .expiry_seconds(18000u64) // 5 hours, max!
+        .into_future()
         .await
         .unwrap();
     println!(
@@ -137,11 +135,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // All includes read and write.
     let permission_mode = get_collection_response.collection.all_permission();
     let create_permission_response = permission_client
-        .create_permission(
-            Context::new(),
-            CreatePermissionOptions::new().expiry_seconds(18000u64), // 5 hours, max!
-            &permission_mode,
-        )
+        .create_permission(permission_mode)
+        .expiry_seconds(18000u64)
+        .into_future()
         .await
         .unwrap();
     println!(

sdk/data_cosmos/src/clients/permission_client.rs

@@ -44,38 +44,17 @@ impl PermissionClient {
     }
 
     /// Create the permission
-    pub async fn create_permission(
-        &self,
-        ctx: Context,
-        options: CreatePermissionOptions,
-        permission_mode: &PermissionMode<'_>,
-    ) -> crate::Result<PermissionResponse<'_>> {
-        let mut request = self.cosmos_client().prepare_request_pipeline(
-            &format!(
-                "dbs/{}/users/{}/permissions",
-                self.database_client().database_name(),
-                self.user_client().user_name()
-            ),
-            http::Method::POST,
-        );
-
-        options.decorate_request(&mut request, self.permission_name(), permission_mode)?;
-
-        let response = self
-            .pipeline()
-            .send(ctx.clone().insert(ResourceType::Permissions), &mut request)
-            .await?;
-
-        Ok(PermissionResponse::try_from(response).await?)
+    pub fn create_permission(&self, permission_mode: PermissionMode) -> CreatePermissionBuilder {
+        CreatePermissionBuilder::new(self.clone(), permission_mode)
     }
 
     /// Replace the permission
     pub async fn replace_permission(
         &self,
         ctx: Context,
         options: ReplacePermissionOptions,
-        permission_mode: &PermissionMode<'_>,
-    ) -> crate::Result<PermissionResponse<'_>> {
+        permission_mode: &PermissionMode,
+    ) -> crate::Result<PermissionResponse> {
         let mut request = self.prepare_request_with_permission_name(http::Method::PUT);
 
         options.decorate_request(&mut request, self.permission_name(), permission_mode)?;
@@ -93,7 +72,7 @@ impl PermissionClient {
         &self,
         ctx: Context,
         options: GetPermissionOptions,
-    ) -> crate::Result<PermissionResponse<'_>> {
+    ) -> crate::Result<PermissionResponse> {
         let mut request = self.prepare_request_with_permission_name(http::Method::GET);
 
         options.decorate_request(&mut request)?;
@@ -136,7 +115,7 @@ impl PermissionClient {
         )
     }
 
-    fn pipeline(&self) -> &Pipeline {
+    pub(crate) fn pipeline(&self) -> &Pipeline {
         self.cosmos_client().pipeline()
     }
 }

sdk/data_cosmos/src/operations/create_permission.rs

@@ -1,19 +1,25 @@
 use crate::prelude::*;
-use crate::resources::permission::{ExpirySeconds, PermissionMode};
+use crate::resources::permission::{ExpirySeconds, PermissionMode, PermissionResponse};
 
-use azure_core::Request as HttpRequest;
+use azure_core::Context;
 
 #[derive(Debug, Clone)]
-pub struct CreatePermissionOptions {
+pub struct CreatePermissionBuilder {
+    client: PermissionClient,
     expiry_seconds: Option<ExpirySeconds>,
     consistency_level: Option<ConsistencyLevel>,
+    permission_mode: PermissionMode,
+    context: Context,
 }
 
-impl CreatePermissionOptions {
-    pub fn new() -> Self {
+impl CreatePermissionBuilder {
+    pub(crate) fn new(client: PermissionClient, permission_mode: PermissionMode) -> Self {
         Self {
+            client,
             expiry_seconds: Some(ExpirySeconds::new(3600)),
             consistency_level: None,
+            permission_mode,
+            context: Context::new(),
         }
     }
 
@@ -22,30 +28,47 @@ impl CreatePermissionOptions {
         consistency_level: ConsistencyLevel => Some(consistency_level),
     }
 
-    pub(crate) fn decorate_request(
-        &self,
-        request: &mut HttpRequest,
-        id: &str,
-        permission_mode: &PermissionMode<'_>,
-    ) -> crate::Result<()> {
-        azure_core::headers::add_optional_header2(&self.consistency_level, request)?;
-        azure_core::headers::add_optional_header2(&self.expiry_seconds, request)?;
-
-        #[derive(Serialize, Deserialize)]
-        struct RequestBody<'x> {
-            id: &'x str,
-            #[serde(rename = "permissionMode")]
-            permission_mode: &'x str,
-            resource: &'x str,
-        }
+    pub fn into_future(self) -> CreatePermission {
+        Box::pin(async move {
+            let mut request = self.client.cosmos_client().prepare_request_pipeline(
+                &format!(
+                    "dbs/{}/users/{}/permissions",
+                    self.client.database_client().database_name(),
+                    self.client.user_client().user_name()
+                ),
+                http::Method::POST,
+            );
+
+            azure_core::headers::add_optional_header2(&self.consistency_level, &mut request)?;
+            azure_core::headers::add_optional_header2(&self.expiry_seconds, &mut request)?;
+
+            #[derive(Serialize, Deserialize)]
+            struct RequestBody<'x> {
+                id: &'x str,
+                #[serde(rename = "permissionMode")]
+                permission_mode: &'x str,
+                resource: &'x str,
+            }
 
-        let request_body = RequestBody {
-            id,
-            permission_mode: permission_mode.kind(),
-            resource: permission_mode.resource(),
-        };
+            let request_body = RequestBody {
+                id: &self.client.permission_name(),
+                permission_mode: self.permission_mode.kind(),
+                resource: self.permission_mode.resource(),
+            };
 
-        request.set_body(bytes::Bytes::from(serde_json::to_string(&request_body)?).into());
-        Ok(())
+            request.set_body(bytes::Bytes::from(serde_json::to_string(&request_body)?).into());
+            let response = self
+                .client
+                .pipeline()
+                .send(
+                    self.context.clone().insert(ResourceType::Permissions),
+                    &mut request,
+                )
+                .await?;
+
+            Ok(PermissionResponse::try_from(response).await?)
+        })
     }
 }
+
+type CreatePermission = futures::future::BoxFuture<'static, crate::Result<PermissionResponse>>;

sdk/data_cosmos/src/operations/replace_permission.rs

@@ -26,7 +26,7 @@ impl ReplacePermissionOptions {
         &self,
         request: &mut HttpRequest,
         id: &str,
-        permission_mode: &PermissionMode<'_>,
+        permission_mode: &PermissionMode,
     ) -> crate::Result<()> {
         azure_core::headers::add_optional_header2(&self.consistency_level, request)?;
         azure_core::headers::add_optional_header2(&self.expiry_seconds, request)?;

sdk/data_cosmos/src/requests/list_permissions_builder.rs

@@ -36,7 +36,7 @@ impl<'a, 'b> ListPermissionsBuilder<'a, 'b> {
         max_item_count: i32 => MaxItemCount::new(max_item_count),
     }
 
-    pub async fn execute(&self) -> crate::Result<ListPermissionsResponse<'a>> {
+    pub async fn execute(&self) -> crate::Result<ListPermissionsResponse> {
         trace!("ListPermissionsBuilder::execute called");
 
         let request = self.user_client.cosmos_client().prepare_request(
@@ -66,7 +66,7 @@ impl<'a, 'b> ListPermissionsBuilder<'a, 'b> {
             .try_into()?)
     }
 
-    pub fn stream(&self) -> impl Stream<Item = crate::Result<ListPermissionsResponse<'a>>> + '_ {
+    pub fn stream(&self) -> impl Stream<Item = crate::Result<ListPermissionsResponse>> + '_ {
         #[derive(Debug, Clone, PartialEq)]
         enum States {
             Init,

sdk/data_cosmos/src/resources/mod.rs

@@ -40,12 +40,12 @@ pub trait Resource {
     fn uri(&self) -> &str;
 
     /// Get the read permissions for the resource
-    fn read_permission(&self) -> PermissionMode<'_> {
+    fn read_permission(&self) -> PermissionMode {
         PermissionMode::read(self)
     }
 
     /// Get all permissions for the resource
-    fn all_permission(&self) -> PermissionMode<'_> {
+    fn all_permission(&self) -> PermissionMode {
         PermissionMode::all(self)
     }
 }

sdk/data_cosmos/src/resources/permission/permission.rs

@@ -11,16 +11,16 @@ use std::borrow::Cow;
 /// attachments, stored procedures, triggers, and user-defined functions for a particular user.
 /// You can learn more about permissions [here](https://docs.microsoft.com/rest/api/cosmos-db/permissions).
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Permission<'a> {
+pub struct Permission {
     ///  The unique name that identifies the permission.
-    pub id: Cow<'a, str>,
+    pub id: String,
     #[serde(flatten)]
     /// The access mode on the resource for the user
     ///
     /// Represented as both "permissionMode" and "resource" in the JSON representation.
-    pub permission_mode: PermissionMode<'a>,
+    pub permission_mode: PermissionMode,
     #[serde(rename = "_rid")]
-    rid: Cow<'a, str>,
+    rid: String,
     /// The last updated timestamp of the resource.
     ///
     /// Represented as "_ts" in the JSON representation.
@@ -30,12 +30,12 @@ pub struct Permission<'a> {
     ///
     /// Represented as "_self" in the JSON representation.
     #[serde(rename = "_self")]
-    pub uri: Cow<'a, str>,
+    pub uri: String,
     /// The resource etag required for optimistic concurrency control.
     ///
     /// Represented as "_etag" in the JSON representation.
     #[serde(rename = "_etag")]
-    pub etag: Cow<'a, str>,
+    pub etag: String,
     /// The resource token for the particular resource and user.
     ///
     /// Represented as "_token" in the JSON representation.
@@ -51,22 +51,22 @@ pub struct Permission<'a> {
 /// Constructing a `PermissionMode` manually is error prone. Use one of the constructor methods
 /// (i.e., [`PermissionMode::read`] or [`PermissionMode::all`]) or get a permission directly
 /// from a resource (e.g., `Collection::read_permission`).
-pub enum PermissionMode<'a> {
+pub enum PermissionMode {
     /// read, write, and delete access
-    All(Cow<'a, str>),
+    All(Cow<'static, str>),
     /// read access only
-    Read(Cow<'a, str>),
+    Read(Cow<'static, str>),
 }
 
-impl<'a> PermissionMode<'a> {
+impl PermissionMode {
     /// Read permission for a given resource
-    pub fn read<T: Resource + ?Sized + 'a>(resource: &'a T) -> Self {
-        PermissionMode::Read(Cow::Borrowed(resource.uri()))
+    pub fn read<T: Resource + ?Sized>(resource: &T) -> Self {
+        PermissionMode::Read(Cow::Owned(resource.uri().to_owned()))
     }
 
     /// Read, write, and delete permissions for a given resource
-    pub fn all<T: Resource + ?Sized + 'a>(resource: &'a T) -> Self {
-        PermissionMode::All(Cow::Borrowed(resource.uri()))
+    pub fn all<T: Resource + ?Sized>(resource: &T) -> Self {
+        PermissionMode::All(Cow::Owned(resource.uri().to_owned()))
     }
 
     /// The kind of permission mode as a string. Either "All" or "Read".
@@ -86,7 +86,7 @@ impl<'a> PermissionMode<'a> {
     }
 }
 
-impl<'a> std::convert::TryFrom<&[u8]> for Permission<'a> {
+impl std::convert::TryFrom<&[u8]> for Permission {
     type Error = crate::Error;
 
     fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
@@ -112,7 +112,7 @@ mod tests {
 
     #[test]
     fn parse_permission() {
-        let permission: Permission<'_> = serde_json::from_str(PERMISSION_JSON).unwrap();
+        let permission: Permission = serde_json::from_str(PERMISSION_JSON).unwrap();
 
         assert_eq!(
             permission.permission_token,

sdk/data_cosmos/src/resources/permission/permission_response.rs

@@ -6,8 +6,8 @@ use azure_core::{collect_pinned_stream, Response as HttpResponse};
 use super::Permission;
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct PermissionResponse<'a> {
-    pub permission: Permission<'a>,
+pub struct PermissionResponse {
+    pub permission: Permission,
     pub charge: f64,
     pub activity_id: uuid::Uuid,
     pub etag: String,
@@ -16,8 +16,8 @@ pub struct PermissionResponse<'a> {
     pub alt_content_path: String,
 }
 
-impl<'a> PermissionResponse<'a> {
-    pub async fn try_from(response: HttpResponse) -> crate::Result<PermissionResponse<'a>> {
+impl PermissionResponse {
+    pub async fn try_from(response: HttpResponse) -> crate::Result<PermissionResponse> {
         let (_status_code, headers, pinned_stream) = response.deconstruct();
         let body = collect_pinned_stream(pinned_stream).await?;