Struct IssuesService

Source

pub struct IssuesService<'a> { /* private fields */ }

Expand description

Issue operations. Obtained via LinearClient::issues; Copy, so it can be freely captured by pagination closures.

Implementations§

Source §

impl<'a> IssuesService<'a>

Source

pub async fn get(&self, issue: impl Into<IssueRef>) -> Result<Issue>

Fetches one issue by UUID or human identifier.

let client = linear_api::LinearClient::from_env()?;
let issue = client
    .issues()
    .get(linear_api::IssueRef::identifier("ENG-123"))
    .await?;
assert_eq!(issue.identifier, "ENG-123");

Source

pub async fn list(&self, req: ListIssuesRequest) -> Result<Page<Issue>>

Fetches one page of issues.

use linear_api::issues::ListIssuesRequest;

let client = linear_api::LinearClient::from_env()?;
let page = client
    .issues()
    .list(ListIssuesRequest::builder().first(25).build())
    .await?;
println!("{} issues, more: {}", page.nodes.len(), page.page_info.has_next_page);

Source

pub fn list_stream( &self, req: ListIssuesRequest, ) -> impl Stream<Item = Result<Issue>> + 'a

Lazily streams issues across pages, starting from req.after when set (the cursor then advances page by page).

use futures::TryStreamExt;
use linear_api::issues::ListIssuesRequest;

let client = linear_api::LinearClient::from_env()?;
let issues = client.issues();
let mut stream = std::pin::pin!(
    issues.list_stream(ListIssuesRequest::builder().first(50).build())
);
while let Some(issue) = stream.try_next().await? {
    println!("{}: {}", issue.identifier, issue.title);
}

Source

pub async fn search( &self, req: SearchIssuesRequest, ) -> Result<Page<IssueSearchResult>>

Full-text search over issues via the searchIssues API (rate-limited by Linear to 30 requests per minute).

use linear_api::issues::SearchIssuesRequest;

let client = linear_api::LinearClient::from_env()?;
let hits = client
    .issues()
    .search(SearchIssuesRequest::builder().term("flux capacitor").build())
    .await?;
for hit in &hits.nodes {
    println!("{}: {}", hit.identifier, hit.title);
}

Source

pub async fn create(&self, input: IssueCreateInput) -> Result<Issue>

Creates one issue.

use linear_api::TeamId;
use linear_api::issues::IssueCreateInput;

let client = linear_api::LinearClient::from_env()?;
let issue = client
    .issues()
    .create(
        IssueCreateInput::builder()
            .team_id(TeamId::new("9cfb482a-81e3-4154-b5b9-2c805e70a02d"))
            .title("Fix the flux capacitor")
            .build(),
    )
    .await?;
println!("created {}", issue.identifier);

Source

pub async fn batch_create( &self, issues: Vec<IssueCreateInput>, ) -> Result<Vec<Issue>>

Creates several issues in one transaction (issueBatchCreate).

use linear_api::TeamId;
use linear_api::issues::IssueCreateInput;

let client = linear_api::LinearClient::from_env()?;
let team = TeamId::new("9cfb482a-81e3-4154-b5b9-2c805e70a02d");
let issues = client
    .issues()
    .batch_create(vec![
        IssueCreateInput::builder().team_id(team.clone()).title("One").build(),
        IssueCreateInput::builder().team_id(team).title("Two").build(),
    ])
    .await?;
assert_eq!(issues.len(), 2);

Source

pub async fn update( &self, issue: impl Into<IssueRef>, input: IssueUpdateInput, ) -> Result<Issue>

Updates one issue by UUID or human identifier. See IssueUpdateInput for set/clear/leave-unchanged semantics.

use linear_api::issues::IssueUpdateInput;
use linear_api::{IssueRef, Undefinable};

let client = linear_api::LinearClient::from_env()?;
let issue = client
    .issues()
    .update(
        IssueRef::identifier("ENG-123"),
        IssueUpdateInput::builder()
            .title("Fix the flux capacitor for real")
            .due_date(Undefinable::Null) // clear the due date
            .build(),
    )
    .await?;
println!("updated {}", issue.identifier);

Source

pub async fn archive(&self, issue: impl Into<IssueRef>) -> Result<()>

Archives one issue.

let client = linear_api::LinearClient::from_env()?;
client
    .issues()
    .archive(linear_api::IssueRef::identifier("ENG-123"))
    .await?;

Source

pub async fn delete(&self, issue: impl Into<IssueRef>) -> Result<()>

Deletes (trashes) one issue. Linear keeps trashed issues recoverable for a grace period.

let client = linear_api::LinearClient::from_env()?;
client
    .issues()
    .delete(linear_api::IssueRef::identifier("ENG-123"))
    .await?;

Source

pub async fn add_label( &self, issue: impl Into<IssueRef>, label: &LabelId, ) -> Result<Issue>

Adds one label to an issue, returning the updated issue. For bulk label changes prefer IssuesService::update with IssueUpdateInput::added_label_ids.

let client = linear_api::LinearClient::from_env()?;
let label = linear_api::LabelId::new("2f7fb5b1-9d5d-4d70-a806-04f8ad4c3702");
let issue = client
    .issues()
    .add_label(linear_api::IssueRef::identifier("ENG-123"), &label)
    .await?;
println!("{} now has {} labels", issue.identifier, issue.labels.len());

Source

pub async fn remove_label( &self, issue: impl Into<IssueRef>, label: &LabelId, ) -> Result<Issue>

Removes one label from an issue, returning the updated issue. For bulk label changes prefer IssuesService::update with IssueUpdateInput::removed_label_ids.

let client = linear_api::LinearClient::from_env()?;
let label = linear_api::LabelId::new("2f7fb5b1-9d5d-4d70-a806-04f8ad4c3702");
let issue = client
    .issues()
    .remove_label(linear_api::IssueRef::identifier("ENG-123"), &label)
    .await?;
println!("{} now has {} labels", issue.identifier, issue.labels.len());