Struct RelationsService 

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

Issue-relation operations: the blocks/blocked-by DAG edges between issues. Obtain via LinearClient::relations.

Direction semantics

The relation type enum has no blockedBy value; direction is positional. type: blocks means the source issue (issueId) blocks the target issue (relatedIssueId). “X is blocked by Y” is therefore created as create(Y, X, Blocks) — or with create_blocks, which names its parameters — and read from X’s incoming edges via IssueRelations::blocked_by.

Implementations

impl RelationsService<'_>

pub async fn create( &self, issue: impl Into<IssueRef>, related: impl Into<IssueRef>, relation_type: IssueRelationType, ) -> Result<IssueRelation>

Creates a relation edge: issue → related with the given type.

Direction matters: for IssueRelationType::Blocks, issue blocks related (there is no blockedBy type). To record “X is blocked by Y”, call create(Y, X, Blocks). Both sides accept a UUID IssueId or a human identifier via IssueRef::identifier.

Examples

use linear_api::{IssueRef, IssueRelationType, LinearClient};

let client = LinearClient::from_env()?;
// ENG-1 blocks ENG-2:
let relation = client
    .relations()
    .create(
        IssueRef::identifier("ENG-1"),
        IssueRef::identifier("ENG-2"),
        IssueRelationType::Blocks,
    )
    .await?;
assert_eq!(relation.issue.identifier, "ENG-1");

pub async fn create_blocks( &self, blocker: impl Into<IssueRef>, blocked: impl Into<IssueRef>, ) -> Result<IssueRelation>

Records that blocker blocks blocked — shorthand for create(blocker, blocked, Blocks) with the direction spelled out in the parameter names.

Examples

use linear_api::{IssueRef, LinearClient};

let client = LinearClient::from_env()?;
// ENG-2 cannot start until ENG-1 is done:
client
    .relations()
    .create_blocks(
        IssueRef::identifier("ENG-1"), // blocker
        IssueRef::identifier("ENG-2"), // blocked
    )
    .await?;

pub async fn delete(&self, id: &IssueRelationId) -> Result<()>

Deletes a relation edge by its ID.

Examples

use linear_api::{IssueRef, LinearClient};

let client = LinearClient::from_env()?;
let relations = client
    .relations()
    .of_issue(IssueRef::identifier("ENG-3"))
    .await?;
if let Some(edge) = relations.outgoing.first() {
    client.relations().delete(&edge.id).await?;
}

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

Fetches both directions of an issue’s relation edges: outgoing = Issue.relations (this issue is the source), incoming = Issue.inverseRelations (this issue is the target).

Fetches up to 50 edges per direction and does not paginate — far beyond any sane card’s edge count. Accepts a UUID or a human identifier via IssueRef::identifier.

Examples

let client = linear_api::LinearClient::from_env()?;
let relations = client
    .relations()
    .of_issue(linear_api::IssueRef::identifier("ENG-3"))
    .await?;
println!(
    "blocks {} issue(s), blocked by {}",
    relations.blocks().len(),
    relations.blocked_by().len(),
);

Trait Implementations

impl<'a> Clone for RelationsService<'a>

fn clone(&self) -> RelationsService<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for RelationsService<'a>