firebase-storage 0.1.0

//! # Firebase Storage Rust SDK
//! The Firebase Storage Rust SDK provides a convenient way to interact with Firebase Storage in Rust applications. It utilizes the Firebase App SDK and API Request Utils crate to handle authentication and make API requests to Firebase Storage.
//! ## Usage
//! Here's an example of how to use the Firebase Storage Rust SDK:
//! ```rust
//! use firebase_app_sdk::App;
//! use firebase_storage_sdk::Storage;
//! use api_request_utils_rs::StatusCode;
//! #[tokio::main]
//! async fn main() -> std::result::Result<(), StatusCode> {
//!     // Initialize the Firebase app
//!     let app = App::initialize().await?;
//! 
//!     // Create a Firebase Storage instance
//!     let storage = Storage::new(&app);
//! 
//!     // Add a linked storage bucket to the Firebase project
//!     let bucket = storage.add_firebase().await?;
//!     println!("Bucket name: {}", bucket.name);
//! 
//!     // Remove the linked storage bucket from the Firebase project
//!     storage.remove_firebase().await?;
//!     println!("Bucket unlinked successfully.");
//! 
//!     // List the linked storage buckets for the Firebase project
//!     let result = storage.list("", 10).await?;
//!     println!("Buckets:");
//!     for bucket in result.buckets {
//!         println!("Bucket name: {}", bucket.name);
//!     }
//!     if let Some(next_page_token) = result.next_page_token {
//!         println!("Next page token: {}", next_page_token);
//!     }
//! 
//!     Ok(())
//! }
//! ```

use firebase_app_sdk::App;

use api_request_utils_rs::{
    Client,
    RequestHandler,
    RequestDefaults,
    RequestBuilder,
    ParameterHashMap,
    StatusCode,
};


/// Represents a storage bucket in Firebase Storage.
#[derive(serde::Deserialize)]
pub struct Bucket {
    pub name : String
}

/// Represents a collection of storage buckets with an optional next page token.
#[derive(serde::Deserialize)]
pub struct Buckets {
    pub buckets : Vec<Bucket>,
    #[serde(rename = "nextPageToken")]
    pub next_page_token : Option<String>
}

/// Represents the Firebase Storage service.
pub struct Storage<'a> {
    app : &'a App<'a>,
    client : Client
}

impl RequestDefaults<'_> for Storage<'_> {
    fn default_post_requestor(&self, endpoint : &str, _: &str) -> RequestBuilder { 
        self.client.post(Self::join_endpoints(&endpoint)) 
    }
    fn default_get_requestor(&self, _: &str, _: ParameterHashMap) -> RequestBuilder { panic!("GET METHOD SHOULD NOT BE USED FOR FIREBASE-Storage struct") }
}

impl RequestHandler<'_> for Storage<'_> {
    const BASE_URL: &'static str = "https://firebasestorage.googleapis.com/v1beta";
}

impl<'a> Storage<'a> {
    /// Creates a new instance of Firebase Storage.
    pub fn new(app : &'a App<'a>) -> Self {
        let client = Client::new();
        Storage { app, client }
    }

    /// Links a Google Cloud Storage bucket to the Firebase project.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use firebase_app_sdk::App;
    /// # use firebase_storage_sdk_sdk::Storage;
    /// # use api_request_utils_rs::StatusCode;
    /// #
    /// # async fn example(app: &App<'_>) -> std::result::Result<(), StatusCode> {
    /// let storage = Storage::new(app);
    /// let result = storage.add_firebase().await?;
    /// println!("Bucket name: {}", result.name);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_firebase(&self) -> std::result::Result<Bucket, StatusCode> {
        let endpoint = format!("projects/{}/buckets/{}.appspot.com",self.app.name,self.app.name);
        let request : RequestBuilder = self.default_post_requestor("addFirebase",&endpoint);
        self.request::<Bucket>(request).await
    }

    /// Unlinks a linked Google Cloud Storage bucket from the Firebase project.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use firebase_app_sdk::App;
    /// # use firebase_storage_sdk::Storage;
    /// # use api_request_utils_rs::StatusCode;
    /// #
    /// # async fn example(app: &App<'_>) -> std::result::Result<(), StatusCode> {
    /// let storage = Storage::new(app);
    /// storage.remove_firebase().await?;
    /// println!("Bucket unlinked successfully.");
    /// # Ok(())
    /// # }
    /// ```
    pub async fn remove_firebase(&self) -> std::result::Result<(), StatusCode> {
        let endpoint = format!("projects/{}/buckets/{}.appspot.com",self.app.name,self.app.name);
        let request : RequestBuilder = self.default_post_requestor("removeFirebase",&endpoint);
        self.request(request).await
    }

    /// Lists the linked storage buckets for the Firebase project.
    ///
    /// # Arguments
    ///
    /// * `page_token` - The page token for pagination.
    /// * `page_size` - The maximum number of buckets to include in a single page.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use firebase_app_sdk::App;
    /// # use firebase_storage_sdk::Storage;
    /// # use api_request_utils_rs::StatusCode;
    /// #
    /// # async fn example(app: &App<'_>) -> std::result::Result<(), StatusCode> {
    /// let storage = Storage::new(app);
    /// let result = storage.list("", 10).await?;
    ///
    /// println!("Buckets:");
    /// for bucket in result.buckets {
    ///     println!("Bucket name: {}", bucket.name);
    /// }
    ///
    /// if let Some(next_page_token) = result.next_page_token {
    ///     println!("Next page token: {}", next_page_token);
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn list(&self,page_token :&str,page_size : u8) -> std::result::Result<Buckets, StatusCode> {
        let endpoint = format!("projects/{}/buckets",self.app.name);
        let request : RequestBuilder = self.default_post_requestor("",&endpoint)
            .query(
                &[
                    ("pageToken",page_token),
                    ("pageSize",&page_size.to_string())
                ]
            );
        self.request(request).await
    }

    /// Gets a single linked storage bucket from the Firebase project.
    ///
    /// # Arguments
    ///
    /// * `name` - The name of the storage bucket.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use firebase_app_sdk::App;
    /// # use firebase_storage_sdk::Storage;
    /// # use api_request_utils_rs::StatusCode;
    /// #
    /// # async fn example(app: &App<'_>) -> std::result::Result<(), StatusCode> {
    /// let storage = Storage::new(app);
    /// let result = storage.get("my-bucket").await?;
    ///
    /// println!("Buckets:");
    /// for bucket in result.buckets {
    ///     println!("Bucket name: {}", bucket.name);
    /// }
    ///
    /// if let Some(next_page_token) = result.next_page_token {
    ///     println!("Next page token: {}", next_page_token);
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get(&self,name : &str) -> std::result::Result<Buckets, StatusCode> {
        let endpoint = format!("projects/{}/buckets/{}",self.app.name,self.app.name);
        let request : RequestBuilder = self.default_post_requestor("",&endpoint)
            .query(&[("name",name)]);
        self.request(request).await
    }
}