Struct Client 

pub struct Client { /* private fields */ }

A client for interacting with the Thunderstore API.

The easiest way to create a client is to use the Client::new method. If you need more control over the client’s configuration, use the Client::builder method instead.

Implementations

impl Client

pub fn new() -> Self

Creates a new client with the default configuration.

pub fn builder() -> ClientBuilder

Creates a ClientBuilder to configure a new client.

pub fn base_url(&self) -> &str

The base URL to use for requests. Defaults to https://thunderstore.io.

pub fn set_base_url(&mut self, base_url: impl Into<String>)

Sets the base URL to use for requests.

pub fn token(&self) -> Option<&str>

The API token to use for restricted endpoints.

pub fn clear_token(&mut self)

Clears the API token to use for restricted endpoints.

pub fn set_token(&mut self, token: impl Into<String>)

Sets the API token to use for restricted endpoints.

pub async fn stream_download( &self, version: impl IntoVersionIdent<'_>, ) -> Result<impl Stream<Item = Result<Bytes>>>

Downloads a package and streams it. The result, when aggregated, is a ZIP archive containing the contents of the package.

pub async fn download( &self, version: impl IntoVersionIdent<'_>, ) -> Result<Bytes>

Downloads a package and returns it as a single Bytes. The result is a ZIP archive containing the contents of the package.

impl Client

pub async fn get_communities( &self, cursor: Option<impl AsRef<str>>, ) -> Result<(CursorState, Vec<Community>)>

Fetches a page of communities.

Returns a CursorState which is used to navigate between pages by passing the fields in the cursor parameter.

pub async fn get_categories( &self, community: impl AsRef<str>, cursor: Option<impl AsRef<str>>, ) -> Result<(CursorState, Vec<CommunityCategory>)>

Fetches a page of categories from the given community.

Returns a CursorState which is used to navigate between pages by passing the fields in the cursor parameter.

impl Client

pub async fn get_current_community(&self) -> Result<Community>

Fetches the start/main community of the client’s base URL.

For the default thunderstore repo, this is riskofrain2.

impl Client

pub async fn render_markdown( &self, markdown: impl Into<String>, ) -> Result<String>

Renders a markdown string to HTML.

impl Client

pub async fn create_profile(&self, data: impl AsRef<[u8]>) -> Result<Uuid>

Creates a profile with the given data and returns its key.

The data is expected to be a ZIP archive containing a export.r2x file and eventual config files or directories. However, any arbitrary data is allowed.

The returned key is used to retrieve the profile with Client::get_profile.

pub async fn create_profile_raw(&self, data: Vec<u8>) -> Result<Uuid>

Creates a profile with the given data and returns its key.

The data is expected to be a base64-encoded ZIP archive containing a export.r2x file and eventual config files or directories. However, any arbitrary data is allowed.

The returned key is used to retrieve the profile with Client::get_profile.

pub async fn get_profile(&self, key: Uuid) -> Result<Vec<u8>>

Downloads a profile with the given key.

The returned data is usually a ZIP archive containing a export.r2x file and eventual config files.

This assumes the profile is encoded with base64, but any arbitrary data is allowed.

pub async fn get_profile_raw(&self, key: Uuid) -> Result<Bytes>

Downloads a profile with the given key.

The returned data is usually a base64-encoded ZIP archive containing a export.r2x file and eventual config files, but any arbitrary data is allowed.

impl Client

pub async fn get_package( &self, ident: impl IntoPackageIdent<'_>, ) -> Result<Package>

Fetches information about a package.

Example

let client = thunderstore::Client::new();

let a = client.get_package(("Kesomannen", "GaleModManager")).await?;
let b = client.get_package("Kesomannen-GaleModManager").await?;

assert_eq!(a, b);

pub async fn get_version( &self, ident: impl IntoVersionIdent<'_>, ) -> Result<PackageVersion>

Fetches information about a specific version of a package.

Example

let client = thunderstore::Client::new();

let a = client.get_version(("Kesomannen", "GaleModManager", "0.6.0")).await?;
let b = client.get_version("Kesomannen-GaleModManager-0.6.0").await?;

assert_eq!(a, b);

pub async fn get_readme( &self, ident: impl IntoVersionIdent<'_>, ) -> Result<String>

Fetches the readme for a specific version of a package. The readme is returned as a markdown string.

pub async fn get_changelog( &self, ident: impl IntoVersionIdent<'_>, ) -> Result<String>

Fetches the changelog for a specific version of a package. The changelog is returned as a markdown string.

Note that a package may not have a changelog, in which case [Error::NotFound] is returned.

impl Client

pub async fn submit_package( &self, upload_uuid: Uuid, metadata: PackageMetadata, ) -> Result<PackageSubmissionResult>

Publishes a pre-uploaded package.

The contents must already have been uploaded by calling Client::initiate_upload, streaming the data to the returned URLs, and finally calling Client::finish_upload.

This method requires an API token on the client.

pub async fn validate_icon(&self, data: impl AsRef<[u8]>) -> Result<bool>

Validates a package icon.

pub async fn validate_manifest_v1( &self, namespace: impl Into<String>, content: impl Into<String>, ) -> Result<bool>

Validates a package manifest (v1) as if uploaded in given namespace.

pub async fn validate_readme(&self, content: impl Into<String>) -> Result<bool>

Validates a package README.

impl Client

pub async fn initiate_upload( &self, name: impl Into<String>, size: u64, ) -> Result<UserMediaInitiateUploadResponse>

Initiates a new package upload.

• name is the name of the package and may only contain alphanumeric characters and underscores.

• size must be the size of the package in bytes.

This method returns a UserMediaInitiateUploadResponse which contains a unique UUID for the upload, which is used to identify the package throughout the upload process.

The response also contains a list of URLs to which the file should be uploaded, using HTTP PUT. Each upload URL responds with an ETag header, which should be used to finalize the upload.

Alternatively, you can use Client::publish to upload and submit a package in one go.

This method requires an API token on the client.

Example

use thunderstore::{Client, models::{UploadPartUrl, CompletedPart}};

let client = Client::builder().with_token("tss_XXX").build()?;

let path = "path/to/your/package.zip";
let size = std::fs::metadata(path)?.len();
let response = client.initiate_upload("MyCoolMod", size).await?;

let parts = Vec::new();

for UploadPartUrl { url, number, offset, length } in response.upload_urls {
   // Read `length` bytes from `offset` in the file
   // and make a PUT request to `url` with the data.

   // The response will return an ETag header, which is needed to complete the upload.
   parts.push(CompletedPart { tag: todo!(), number });

   // These requests should preferably be done concurrently to decrease upload time.
}

client.finish_upload(response.user_media.uuid, parts).await?;

pub async fn abort_upload(&self, uuid: Uuid) -> Result<UserMedia>

Aborts an ongoing upload.

This method requires an API token on the client.

pub async fn finish_upload( &self, uuid: Uuid, parts: Vec<CompletedPart>, ) -> Result<UserMedia>

Finalizes an upload. Requires the UUID of the upload and a list of CompletedPart objects, which contain the ETag of each part of the upload.

Note that this will not publish the package, only finish the upload process. To submit the package, use the Client::submit_package method as well.

This method requires an API token on the client.

pub async fn publish( &self, name: impl Into<String>, data: impl Into<Bytes>, metadata: PackageMetadata, ) -> Result<PackageSubmissionResult>

Uploads and submits a package.

• name may only contain alphanumeric characters and underscores.

This method requires an API token on the client.

impl Client

pub async fn get_wikis(&self) -> Result<WikisResponse>

Fetches an index of all the package wikis on Thunderstore.

pub async fn get_wiki(&self, package: impl IntoPackageIdent<'_>) -> Result<Wiki>

Fetches the wiki of a specific package.

pub async fn create_wiki_page( &self, package: impl IntoPackageIdent<'_>, title: impl Into<String>, content: impl Into<String>, ) -> Result<WikiPage>

Creates a package wiki page.

pub async fn update_wiki_page( &self, package: impl IntoPackageIdent<'_>, id: impl Into<String>, title: impl Into<String>, content: impl Into<String>, ) -> Result<WikiPage>

Updates a package wiki page.

pub async fn upsert_wiki_page( &self, package: impl IntoPackageIdent<'_>, upsert: WikiPageUpsert, ) -> Result<WikiPage>

Upserts a package wiki page.

If upsert.id is None, this creates a new page. Otherwise, an existing one is updated according to its id.

pub async fn delete_wiki_page( &self, package: impl IntoPackageIdent<'_>, id: impl Into<String>, ) -> Result<()>

Deletes a package wiki page.

pub async fn get_wiki_page(&self, id: impl AsRef<str>) -> Result<WikiPage>

Fetches a package wiki page by its id.

impl Client

pub async fn get_metrics( &self, community: impl AsRef<str>, package: impl IntoPackageIdent<'_>, ) -> Result<PackageMetrics>

Fetches PackageMetrics for a specific package.

community is the slug of the community, which is usually in kebab-case.

pub async fn get_downloads( &self, community: impl AsRef<str>, version: impl IntoVersionIdent<'_>, ) -> Result<u64>

Fetches the download count for a specific version of a package.

community is the slug of the community, which is usually in kebab-case.

pub async fn list_packages_v1( &self, community: impl AsRef<str>, ) -> Result<Vec<PackageV1>>

Fetches all available packages in a community and collects them in a Vec.

• community is the slug of the community, which is usually in kebab-case.

Note that on popular communities like Lethal Company (lethal-company), this will fetch up to 170 MB of data.

impl Client

pub async fn stream_packages_v1( &self, community: impl AsRef<str>, ) -> Result<impl Stream<Item = Result<PackageV1>>>

Asynchronously streams all available packages in a community.

• community is the slug of the community, which is usually in kebab-case.

If you just want a Vec of all packages, use Client::list_packages_v1 instead.

Examples

// provides `try_next`
use futures_util::TryStreamExt;
use futures_util::pin_mut;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = thunderstore::Client::new();

    let stream = client.stream_packages_v1("content-warning").await?;
    pin_mut!(stream); // needed for iteration

    while let Some(package) = stream.try_next().await? {
        println!("got {}!", package.name);
    }

   Ok(())
}

Trait Implementations

impl Default for Client

fn default() -> Self

Returns the “default value” for a type.