Struct HttpApi 

pub struct HttpApi {
    pub(crate) http: Http,
}

GitHub’s HTTP implementation of super::Api.

Debug is derived, which stays safe because the transport’s token redacts itself.

Fields

http: Http

Implementations

impl HttpApi

async fn read_actions<R: for<'a> Facet<'a>>( &self, repository: &RepoRef, route: &str, unavailable: Option<u16>, ) -> Result<Option<R>, ForgeError>

async fn put_actions( &self, repository: &RepoRef, route: &str, body: String, ) -> Result<(), ForgeError>

impl HttpApi

pub(crate) async fn tag_commit( &self, repository: &RepoRef, tag: &str, ) -> Result<Option<String>, ForgeError>

pub(crate) async fn open_pull_request_body( &self, repository: &RepoRef, head: &str, base: &str, ) -> Result<Option<String>, ForgeError>

Read the body of the unique open pull request for head and base.

async fn open_pull_request( &self, repository: &RepoRef, head: &str, base: &str, ) -> Result<Option<PullWire>, ForgeError>

async fn pulls( &self, repository: &RepoRef, state: &str, head: &str, base: &str, ) -> Result<Vec<PullWire>, ForgeError>

pub(crate) async fn ensure_pull_request( &self, repository: &RepoRef, head: &str, base: &str, title: &str, body: &str, ) -> Result<(), ForgeError>

Create the proposal pull request, or update its title and body.

pub(crate) async fn release_by_tag( &self, repository: &RepoRef, tag: &str, ) -> Result<Option<RemoteRelease>, ForgeError>

Read a release by its tag.

The tag route serves only published releases and a draft has no tag yet, so this lists the releases and matches on tag_name.

pub(crate) async fn create_draft_release( &self, repository: &RepoRef, tag: &str, target_commit: &str, title: &str, notes: &str, ) -> Result<u64, ForgeError>

Create a draft release and return its stable ID.

pub(crate) async fn assets( &self, repository: &RepoRef, release_id: u64, ) -> Result<Vec<RemoteAsset>, ForgeError>

List all release assets, including size and server-reported digest.

pub(crate) async fn download_asset( &self, repository: &RepoRef, asset: &RemoteAsset, ) -> Result<Vec<u8>, ForgeError>

Download an existing asset for digest verification when GitHub omitted its server-side digest.

Only the asset route with an octet-stream Accept header serves the assets of draft releases and private repositories. It redirects to storage.

pub(crate) async fn upload_asset( &self, repository: &RepoRef, release_id: u64, filename: &str, bytes: Vec<u8>, ) -> Result<(), ForgeError>

Upload one asset to an existing draft release.

Errors

Returns a rejection for an invalid asset filename and an unsupported error if the release is already published.

pub(crate) async fn delete_asset( &self, repository: &RepoRef, asset_id: u64, ) -> Result<(), ForgeError>

Delete one release asset.

pub(crate) async fn publish_release( &self, repository: &RepoRef, release_id: u64, ) -> Result<(), ForgeError>

Publish a fully staged draft.

Errors

Returns an unsupported error if the release is already published.

impl HttpApi

pub(super) async fn put_switch( &self, repository: &RepoRef, name: &str, enabled: bool, ) -> Result<(), ForgeError>

impl HttpApi

pub fn new(base: &Url, token: Token) -> Result<Self, TransportBuildError>

Create a GitHub REST client rooted at base (normally https://api.github.com).

Errors

Returns an error if the underlying HTTP client fails to build.

pub fn with_retry(self, retry: RetryPolicy) -> Self

Replace the retry policy, which keeps tests from sleeping.

async fn send<T: for<'a> Facet<'a>>( &self, method: Method, path: &str, body: Option<String>, ) -> Result<T, ForgeError>

async fn optional<T: for<'a> Facet<'a>>( &self, path: &str, ) -> Result<Option<T>, ForgeError>

A GET that reads a missing resource as None.

async fn empty( &self, method: Method, path: &str, body: Option<String>, ) -> Result<(), ForgeError>

async fn paged<T: for<'a> Facet<'a>>( &self, path: &str, ) -> Result<Vec<T>, ForgeError>

async fn paged_in<R: for<'a> Facet<'a>, T>( &self, path: &str, page_size: usize, items: fn(R) -> Vec<T>, ) -> Result<Vec<T>, ForgeError>

Trait Implementations

impl AccessApi for HttpApi

async fn add_collaborator( &self, repository: &RepoRef, user: &UserName, permission: &Permission, ) -> Result<(), ForgeError>

Grant user the given permission, which invites them if needed.

async fn add_team( &self, repository: &RepoRef, slug: &str, permission: &Permission, ) -> Result<(), ForgeError>

Grant the team with this slug the given permission on the repository.

async fn cancel_invitation( &self, repository: &RepoRef, id: u64, ) -> Result<(), ForgeError>

Cancel the pending invitation id.

async fn collaborators( &self, repository: &RepoRef, ) -> Result<Vec<Collaborator>, ForgeError>

Read the repository’s direct collaborators, without inherited access.

async fn current_user(&self) -> Result<String, ForgeError>

Read the login of the authenticated user.

async fn user_teams(&self) -> Result<Vec<Membership>, ForgeError>

Read the teams the authenticated user belongs to, in any organization.

async fn invitations( &self, repository: &RepoRef, ) -> Result<Vec<Invitation>, ForgeError>

Read the repository’s pending invitations.

async fn organization_teams( &self, organization: &str, ) -> Result<Vec<Team>, ForgeError>

Read the teams available for assignment at organization.

async fn owner_kind(&self, owner: &str) -> Result<OwnerKind, ForgeError>

Read whether owner is an organization or a personal account.

async fn remove_collaborator( &self, repository: &RepoRef, user: &UserName, ) -> Result<(), ForgeError>

Remove user’s direct grant on the repository.

async fn remove_team( &self, repository: &RepoRef, slug: &str, ) -> Result<(), ForgeError>

Remove the direct grant of the team with this slug on the repository.

async fn teams(&self, repository: &RepoRef) -> Result<Vec<Team>, ForgeError>

Read the repository’s current direct team grants.

async fn update_invitation( &self, repository: &RepoRef, id: u64, permission: &Permission, ) -> Result<(), ForgeError>

Change the permission of the pending invitation id.

impl ActionsApi for HttpApi

async fn actions_cache( &self, repository: &RepoRef, ) -> Result<Option<Cache>, ForgeError>

Read the cache limits, or None when GitHub reports the endpoint unavailable.

async fn actions_group<G: ActionsGroup>( &self, repository: &RepoRef, ) -> Result<Option<G>, ForgeError>

Read one settings group, or None when GitHub reports the endpoint unavailable.

async fn set_actions_cache( &self, repository: &RepoRef, group: &Cache, ) -> Result<(), ForgeError>

Replace the cache limits.

async fn set_actions_group<G: ActionsGroup>( &self, repository: &RepoRef, group: &G, ) -> Result<(), ForgeError>

Replace one settings group.

impl AutolinksApi for HttpApi

async fn autolinks( &self, repository: &RepoRef, ) -> Result<Vec<Autolink>, ForgeError>

Read the repository’s autolinks.

async fn create_autolink( &self, repository: &RepoRef, autolink: &AutolinkBody, ) -> Result<(), ForgeError>

Create an autolink.

async fn delete_autolink( &self, repository: &RepoRef, id: u64, ) -> Result<(), ForgeError>

Delete the autolink id.

impl Clone for HttpApi

fn clone(&self) -> HttpApi

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CustomPropertiesApi for HttpApi

async fn custom_property_values( &self, repository: &RepoRef, ) -> Result<Option<Vec<PropertyEntry>>, ForgeError>

Read the custom property values, or None when the repository has no custom properties endpoint.

async fn set_custom_property_values( &self, repository: &RepoRef, entries: &[PropertyEntry], ) -> Result<(), ForgeError>

Set or clear several custom property values in one request.

impl Debug for HttpApi

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EnvironmentsApi for HttpApi

async fn branch_policies( &self, repository: &RepoRef, environment: &str, ) -> Result<Vec<BranchPolicy>, ForgeError>

Read the branch policies of environment.

async fn create_branch_policy( &self, repository: &RepoRef, environment: &str, policy: &Policy, ) -> Result<(), ForgeError>

Add a branch policy to environment.

async fn delete_branch_policy( &self, repository: &RepoRef, environment: &str, id: u64, ) -> Result<(), ForgeError>

Remove the branch policy id from environment.

async fn delete_environment( &self, repository: &RepoRef, environment: &str, ) -> Result<(), ForgeError>

Delete environment.

async fn environments( &self, repository: &RepoRef, ) -> Result<Vec<Environment>, ForgeError>

Read the repository’s environments, without their branch policies.

async fn put_environment( &self, repository: &RepoRef, environment: &str, settings: &EnvironmentBody, ) -> Result<(), ForgeError>

Create environment or replace its settings.

impl LabelsApi for HttpApi

async fn create_label( &self, repository: &RepoRef, name: &str, color: &LabelColor, description: &str, ) -> Result<(), ForgeError>

Create the label name.

async fn delete_label( &self, repository: &RepoRef, name: &str, ) -> Result<(), ForgeError>

Delete the label name.

async fn labels(&self, repository: &RepoRef) -> Result<Vec<Label>, ForgeError>

Read every label of the repository.

async fn update_label( &self, repository: &RepoRef, name: &str, color: &LabelColor, description: &str, ) -> Result<(), ForgeError>

Set the color and description of the label name.

impl PagesApi for HttpApi

async fn create_pages( &self, repository: &RepoRef, site: &PagesCreate, ) -> Result<(), ForgeError>

Create the Pages site.

async fn delete_pages(&self, repository: &RepoRef) -> Result<(), ForgeError>

Delete the Pages site.

async fn pages(&self, repository: &RepoRef) -> Result<Option<Pages>, ForgeError>

Read the Pages site. None means the repository has no site.

async fn update_pages( &self, repository: &RepoRef, site: &PagesUpdate, ) -> Result<(), ForgeError>

Update the Pages site.

impl RepositoryApi for HttpApi

async fn patch_repository( &self, repository: &RepoRef, patch: &RepositoryPatch, ) -> Result<(), ForgeError>

Write only the changed repository fields.

async fn replace_topics( &self, repository: &RepoRef, topics: &[String], ) -> Result<(), ForgeError>

Replace the repository’s topic labels wholesale.

async fn immutable_releases( &self, repository: &RepoRef, ) -> Result<Option<ImmutableReleases>, ForgeError>

Read the immutable-release setting. None means GitHub does not offer it for this repository.

async fn set_immutable_releases( &self, repository: &RepoRef, enabled: bool, ) -> Result<(), ForgeError>

Enable or disable immutable releases.

async fn repository( &self, repository: &RepoRef, ) -> Result<Repository, ForgeError>

Read the repository’s current settings.

impl RulesetsApi for HttpApi

async fn create_ruleset( &self, repository: &RepoRef, name: &str, ruleset: &Definition, ) -> Result<(), ForgeError>

Create a ruleset with its complete desired configuration.

async fn delete_ruleset( &self, repository: &RepoRef, id: u64, ) -> Result<(), ForgeError>

Delete the ruleset id.

async fn rulesets( &self, repository: &RepoRef, ) -> Result<Vec<Ruleset>, ForgeError>

Read the repository’s current rulesets.

async fn update_ruleset( &self, repository: &RepoRef, id: u64, name: &str, ruleset: &Definition, unmanaged_rules: &[Value], ) -> Result<(), ForgeError>

Replace the ruleset id with its complete desired configuration and the live rules that the configuration cannot declare.

impl SecurityApi for HttpApi

async fn automated_security_fixes( &self, repository: &RepoRef, ) -> Result<Option<bool>, ForgeError>

Read whether Dependabot security updates are on. None means GitHub does not answer.

async fn code_scanning_default_setup( &self, repository: &RepoRef, ) -> Result<Option<CodeScanning>, ForgeError>

Read the code scanning default setup. None means GitHub does not answer.

async fn patch_code_scanning_default_setup( &self, repository: &RepoRef, patch: &CodeScanningPatch, ) -> Result<(), ForgeError>

Write only the changed code scanning default setup properties.

async fn patch_security_analysis( &self, repository: &RepoRef, patch: &AnalysisPatch, ) -> Result<(), ForgeError>

Write only the changed security_and_analysis properties.

async fn private_vulnerability_reporting( &self, repository: &RepoRef, ) -> Result<Option<bool>, ForgeError>

Read whether private vulnerability reporting is on. None means GitHub does not answer.

async fn set_automated_security_fixes( &self, repository: &RepoRef, enabled: bool, ) -> Result<(), ForgeError>

Turn Dependabot security updates on or off.

async fn set_private_vulnerability_reporting( &self, repository: &RepoRef, enabled: bool, ) -> Result<(), ForgeError>

Turn private vulnerability reporting on or off.

async fn set_vulnerability_alerts( &self, repository: &RepoRef, enabled: bool, ) -> Result<(), ForgeError>

Turn Dependabot alerts on or off.

async fn vulnerability_alerts( &self, repository: &RepoRef, ) -> Result<Option<bool>, ForgeError>

Read whether Dependabot alerts are on. None means GitHub does not answer.

impl VariablesApi for HttpApi

async fn create_variable( &self, repository: &RepoRef, scope: &VariableScope, variable: &VariableBody, ) -> Result<(), ForgeError>

Create an Actions variable.

async fn delete_variable( &self, repository: &RepoRef, scope: &VariableScope, name: &str, ) -> Result<(), ForgeError>

Delete the Actions variable name.

async fn update_variable( &self, repository: &RepoRef, scope: &VariableScope, variable: &VariableBody, ) -> Result<(), ForgeError>

Change the value of an Actions variable.

async fn variables( &self, repository: &RepoRef, scope: &VariableScope, ) -> Result<Vec<Variable>, ForgeError>

Read the Actions variables in scope.

impl WebhooksApi for HttpApi

async fn create_webhook( &self, repository: &RepoRef, webhook: &WebhookBody, ) -> Result<(), ForgeError>

Create a webhook.

async fn delete_webhook( &self, repository: &RepoRef, id: u64, ) -> Result<(), ForgeError>

Delete the webhook id.

async fn update_webhook( &self, repository: &RepoRef, id: u64, webhook: &WebhookPatch, ) -> Result<(), ForgeError>

Update the webhook id.

async fn webhooks( &self, repository: &RepoRef, ) -> Result<Vec<Webhook>, ForgeError>

Read the repository’s webhooks.