Struct Builder

pub struct Builder {
    pub url: Url,
    pub headers: HeaderMap,
    pub client: Client,
    pub method: Method,
    pub body: Option<BodyType>,
}

Fields

url: Url

headers: HeaderMap

client: Client

method: Method

body: Option<BodyType>

Implementations

impl Builder

pub fn get_buckets(self) -> Executor

retrieve all buckets

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .get_buckets()
    .execute();

pub fn create_bucket(self, body: &str) -> Executor

create a new bucket

Arguments

• body - The request body as a string.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .create_bucket("thefux")
    .execute();

pub fn create_bucket_from(self, body: NewBucket) -> Executor

create a new bucket using a struct

Arguments

• body - The NewBucket struct containing the request body.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .create_bucket_from(NewBucket::new("thefux".to_string()))
    .execute();

pub fn empty_bucket(self, bucket_id: &str) -> Executor

empty the bucket

Arguments

• bucket_id - The identifier of the bucket to empty.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .empty_bucket("thefux")
    .execute();

pub fn get_bucket_details(self, bucket_id: &str) -> Executor

get bucket details

Arguments

• bucket_id - The identifier of the bucket to empty.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .get_bucket_details("thefux")
    .execute();

pub fn update_bucket(self, bucket_id: &str, body: &str) -> Executor

update the bucket

Arguments

• bucket_id - The identifier of the bucket to empty.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .update_bucket("thefux", r#"{ "public": true }"#)
    .execute();

pub fn update_bucket_from(self, bucket_id: &str, body: BucketUpdate) -> Executor

update bucket using a struct

Arguments

• bucket_id - The identifier of the bucket to empty.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::BucketUpdate,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .update_bucket_from("thefux", BucketUpdate {
        public: false,
        file_size_limit: Some(0),
        allowed_mime_types: Some(vec!["application/pdf".to_string()]),
    })
    .execute();

pub fn delete_bucket(self, bucket_id: &str) -> Executor

delete a bucket

Arguments

• bucket_id - The identifier of the bucket to empty.

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
};
use dotenv::dotenv;

dotenv().ok();
let config = SupabaseConfig::default();
let storage = Storage::new_with_config(config)
    .from()
    .delete_bucket("thefux")
    .execute();

impl Builder

pub fn new(url: Url, headers: HeaderMap, client: Client) -> Self

Creates a new Builder instance.

Arguments

• url - The URL for the request.
• headers - The HeaderMap containing the headers for the request.
• client - The Client to use for making the request.

Example

use supabase_storage::build::builder::Builder;
use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::Client;
use url::Url;

let url = Url::parse("http://localhost").unwrap();
let builder = Builder::new(url, HeaderMap::new(), Client::new());

pub fn build(self) -> RequestBuilder

Constructs and returns a RequestBuilder instance based on the current Builder configuration.

Returns

• RequestBuilder - The constructed RequestBuilder instance.

pub fn header(self, key: impl IntoHeaderName, value: HeaderValue) -> Self

Adds a new header to the request.

Arguments

• key - The header name, implementors of IntoHeaderName are accepted.
• value - The header value as a string.

Returns

• Self - The updated Builder instance with the new header added.

Example

use supabase_storage::build::builder::Builder;
use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::Client;
use url::Url;

let url = Url::parse("http://localhost").unwrap();

let _ = Builder::new(url, HeaderMap::new(), Client::new())
    .header("Authorization", HeaderValue::from_static("Bearer <token>"));

pub async fn run(self) -> Result<Response, Error>

Executes the constructed HTTP request and returns the response as a Result.

Returns

• Result<Response, Error> - The result of the executed request.

Example

use supabase_storage::build::builder::Builder;
use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::Client;
use url::Url;

#[tokio::main]
async fn main() {
    let url = Url::parse("http://localhost").unwrap();
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", HeaderValue::from_static("Bearer YOUR_ACCESS_TOKEN"));

    let builder = Builder::new(url, headers, Client::new())
        .header("Authorization", HeaderValue::from_static("Bearer <token>"));

    // Execute the request and handle the response
    let response = builder.run().await;
    match response {
        Ok(response) => {
            let body = response.text().await.unwrap();
            println!("Response body: {:?}", body);
        }
        Err(error) => {
            eprintln!("Error occurred: {:?}", error);
        }
    }
}

pub fn create_executor(self) -> Executor

Creates a new Executor instance based on the current Builder configuration.

Returns

• Executor - The created Executor instance.

impl Builder

pub fn list_objects(self, bucket_id: &str, body: &str) -> Executor

list all files within a bucket

Arguments

• bucket_id - bucket id
• body - request body

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .list_objects("thefux", r#"
            {
                "prefix": "bitcoin.pdf",
                "limit": 100,
                "offset": 0,
                "sortBy": {
                    "column": "name",
                    "order": "asc",
                },
            }"#)
        .execute()
        .await
        .unwrap();
}

impl Builder

pub fn move_object(self, bucket_id: &str, from: &str, to: &str) -> Executor

move an object

Arguments

• bucket_id - bucket id
• from - object soruce
• to - object destination

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .move_object("thefux", "from", "to")
        .execute()
        .await
        .unwrap();
}

pub fn move_object_from(self, obj: MoveCopyObject) -> Executor

move an object

Arguments

• bucket_id - bucket id
• from - object soruce
• to - object destination

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
    model::object::MoveCopyObject,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let move_obj = MoveCopyObject {
        bucket_id: "thefux".to_string(),
        source_key: "from".to_string(),
        destination_key: "to".to_string(),
    };
    let response = Storage::new_with_config(config)
        .from()
        .move_object_from(move_obj)
        .execute()
        .await
        .unwrap();
}

pub fn copy_object(self, bucket_id: &str, from: &str, to: &str) -> Executor

copy an object

Arguments

• bucket_id - bucket id
• from - object soruce
• to - object destination

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .copy_object("thefux", "from", "to")
        .execute()
        .await
        .unwrap();
}

pub fn copy_object_from(self, obj: MoveCopyObject) -> Executor

copy an object

Arguments

• bucket_id - bucket id
• from - object soruce
• to - object destination

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
    model::object::MoveCopyObject,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let move_obj = MoveCopyObject {
        bucket_id: "thefux".to_string(),
        source_key: "from".to_string(),
        destination_key: "to".to_string(),
    };
    let response = Storage::new_with_config(config)
        .from()
        .copy_object_from(move_obj)
        .execute()
        .await
        .unwrap();
}

impl Builder

pub fn get_public_object(self, bucket_id: &str, object: &str) -> Executor

get public object from the storage

Arguments

• bucket_id - bucket id
• object - a wildcard

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .get_public_object("thefux", "file_name.pdf")
        .execute()
        .await
        .unwrap();
}

pub fn get_public_object_info(self, bucket_id: &str, object: &str) -> Executor

get public object info

Arguments

• bucket_id - bucket id
• object - a wildcard

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .get_public_object_info("thefux", "file_name.pdf")
        .execute()
        .await
        .unwrap();
}

impl Builder

pub fn get_object_with_transform( self, bucket_id: &str, object: &str, transform: Transform, ) -> Executor

get public object from the storage

Arguments

• bucket_id - bucket id
• object - object name/path
• transform - tranformation options to transform before serving it to client

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
    model::options::{Transform, Format, Resize}
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .get_object_with_transform("thefux", "test.png", Transform {
            format: Some(Format::Origin),
            height: Some(0),
            quality: Some(0),
            resize: Some(Resize::Cover),
            width: Some(0),
        })
        .execute()
        .await
        .unwrap();
}

impl Builder

pub fn create_signed_url( self, bucket_name: &str, object: &str, body: &str, ) -> Executor

generate presigned url to retrieve an object

Arguments

• bucket_name - bucket name
• object - object name

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .create_signed_url("thefux", "bitcoin.pdf", r#"
            {
                "expiresIn": 3600,
                "transform": {
                    "height": 0,
                    "width": 0,
                    "resize": "cover",
                    "format": "origin",
                    "quality": 100
                }
            }"#)
        .execute()
        .await
        .unwrap();
}

pub fn create_signed_urls(self, bucket_name: &str, body: &str) -> Executor

generate presigned urls to retrieve objects

Arguments

• bucket_name - bucket name
• object - object name

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .create_signed_urls("thefux", r#"{"expiresIn": 3600, "paths": ["hello.pdf", "test.pdf"]}"#)
        .execute()
        .await
        .unwrap();
}

pub fn get_object_with_pre_assigned_url( self, bucket_name: &str, object: &str, token: &str, ) -> Executor

get object via pre-signed url

Arguments

• bucket_name - bucket name
• object - object name
• token - sign token
• file - file object

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;
use tokio::fs::File;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .get_object_with_pre_assigned_url("thefux", "btc.pdf", "<token>")
        .execute()
        .await
        .unwrap();
}

impl Builder

pub fn create_signed_upload_url(self, bucket_id: &str, object: &str) -> Executor

generate pre-signed url to upload an object

Arguments

• bucket_id - bucket id
• object - object name

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .create_signed_upload_url("thefux", "bitcoin.pdf")
        .execute()
        .await
        .unwrap();
}

pub async fn upload_to_signed_url_async( self, bucket_id: &str, object: &str, token: &str, file_path: &str, file_options: FileOptions, ) -> Executor

upload object via pre-signed url

Arguments

• bucket_id - bucket id
• object - object name
• token - sign token
• file_path - file path
• file_options - file options

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
    model::options::FileOptions,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .upload_to_signed_url_async("thefux", "btc.pdf", "<token>", "out/test.pdf", FileOptions {
            cache_control: None,
            content_type: Some("application/pdf".to_string()),
            upsert: Some(true),
        })
        .await
        .execute()
        .await
        .unwrap();
}

pub async fn upload_to_signed_url_no_options_async( self, bucket_id: &str, object: &str, token: &str, file_path: &str, ) -> Executor

upload object via pre-signed url with auto detecting content-type

Arguments

• bucket_id - bucket id
• object - object name
• token - sign token
• file_path - file path

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .upload_to_signed_url_no_options_async("thefux", "btc.pdf", "<token>", "out/test.pdf")
        .await
        .execute()
        .await
        .unwrap();
}

pub fn upload_from_file_with_pre_assigned_url( self, bucket_id: &str, object: &str, token: &str, file: File, file_options: FileOptions, ) -> Executor

upload object via pre-signed url

Arguments

• bucket_id - bucket id
• object - object name
• token - sign token
• file - file object

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
    model::options::FileOptions,
};
use dotenv::dotenv;
use tokio::fs::File;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .upload_from_file_with_pre_assigned_url("thefux", "btc.pdf", "<token>",
            File::open("out/test.pdf").await.unwrap(),
            FileOptions {
                cache_control: None,
                content_type: None,
                upsert: None,
            })
        .execute()
        .await
        .unwrap();
}

impl Builder

pub fn delete_object(self, bucket_id: &str, object: &str) -> Executor

delete an object, could be any kind of data stored in the given storage

Arguments

• bucket_id - bucket id
• object - a wildcard

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .delete_object("thefux", "file_name.pdf")
        .execute()
        .await
        .unwrap();
}

pub fn delete_objects(self, bucket_id: &str, body: &str) -> Executor

delete multiple objects

Arguments

• bucket_id - bucket id
• body - json object with list of perfixes

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .delete_objects("thefux", r#"{ "prefixes" : [ "file_name.pdf" ]}"#)
        .execute()
        .await
        .unwrap();
}

pub fn get_object(self, bucket_name: &str, object: &str) -> Executor

get an object from the storage

Arguments

• bucket_name - bucket name
• object - a wildcard

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .delete_object("thefux", "file_name.pdf")
        .execute()
        .await
        .unwrap();
}

Examples found in repository

examples/get_object.rs (line 17)

async fn main() {
    dotenv().ok();

    let config = SupabaseConfig::default();
    let storage = Storage::new_with_config(config);

    let bucket_name = "thefux";
    let object = "btc.pdf";

    let response = storage
        .from()
        .get_object(bucket_name, object)
        .execute()
        .await
        .unwrap();

    println!("{:?}", response);
}

pub async fn update_object_async( self, bucket_name: &str, object: &str, file_path: &str, ) -> Executor

update an object

Arguments

• bucket_name - bucket name
• object - a wildcard

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .update_object_async("thefux", "file_name.pdf", "out/test.pdf")
        .await
        .execute()
        .await
        .unwrap();
}

pub async fn upload_object( self, bucket_name: &str, object: &str, file_path: &str, ) -> Executor

upload an object

Arguments

• bucket_name - bucket name
• object - object name

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .upload_object("thefux", "file_name.pdf", "out/test.pdf")
        .await
        .execute()
        .await
        .unwrap();
}

pub fn download_object(self, bucket_id: &str) -> Executor

download object

Arguments

• bucket_id - bucket id
• body - request body

Returns

• Executor - The constructed Executor instance for executing the request.

Example

use supabase_storage::{
    Storage,
    config::SupabaseConfig,
    model::bucket::NewBucket,
};
use dotenv::dotenv;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let config = SupabaseConfig::default();
    let response = Storage::new_with_config(config)
        .from()
        .download_object("thefux")
        .execute()
        .await
        .unwrap();
}