proposals.rs 95.1%

309 of 325 lines run, 56 of 124 functions · run #538 on main · run missed

//! The `proposals`, `proposal_comments`, `proposal_reviews` and
//! `proposal_events` tables, and the per-repository number space.

use super::{now_ms, Pool};
use sqlx::FromRow;

#[derive(Clone, Debug, Default, FromRow)]
pub struct ProposalRow {
    pub id: i64,
    pub repo_id: i64,
    pub number: i64,
    pub title: String,
    pub body: String,
    pub author_id: Option<i64>,
    pub author: String,
    pub state: String,
    pub target: String,
    pub source_kind: String,
    pub source_repo_id: Option<i64>,
    pub source_bookmark: String,
    pub source_changes: String,
    pub projected_state: String,
    pub projected_heads: String,
    pub projected_target: String,
    pub projected_changes: String,
    pub conflicted: bool,
    pub landed_state: String,
    pub landed_by: String,
    pub landed_via: String,
    pub landed_ms: i64,
    pub created_ms: i64,
    pub updated_ms: i64,
    /// Who set it to land when its checks pass (#261); empty when off.
    #[sqlx(default)]
    pub auto_land_by: String,
    #[sqlx(default)]
    pub auto_land_ms: Option<i64>,
}

impl ProposalRow {
    pub fn projected_heads(&self) -> Vec<String> {
        self.projected_heads.split(',').filter(|s| !s.is_empty()).map(String::from).collect()
    }

    pub fn projected_changes(&self) -> Vec<String> {
        self.projected_changes.split(',').filter(|s| !s.is_empty()).map(String::from).collect()
    }

    pub fn source_changes(&self) -> Vec<String> {
        self.source_changes.split(',').filter(|s| !s.is_empty()).map(String::from).collect()
    }

    pub fn is_open(&self) -> bool {
        self.state == "open" || self.state == "draft"
    }
}

#[derive(Clone, Debug, FromRow)]
pub struct CommentRow {
    pub id: i64,
    pub proposal_id: i64,
    pub author_id: Option<i64>,
    pub author: String,
    pub body: String,
    pub path: String,
    pub anchor_change: String,
    pub anchor_index: i64,
    pub resolved: bool,
    pub created_ms: i64,
    /// The AI assistant that wrote it for the author (migration 0066),
    /// empty for the author's own comment.
    #[sqlx(default)]
    pub via: String,
}

#[derive(Clone, Debug, FromRow)]
pub struct ReviewRow {
    pub id: i64,
    pub proposal_id: i64,
    /// `None` once the author's account was deleted (its name stays).
    pub author_id: Option<i64>,
    pub author: String,
    pub verdict: String,
    pub body: String,
    pub created_ms: i64,
    /// The AI assistant that answered for the author (migration 0036),
    /// empty for the author's own review.
    #[sqlx(default)]
    pub via: String,
}

#[derive(Clone, Debug, FromRow)]
pub struct EventRow {
    pub id: i64,
    pub at_ms: i64,
    pub actor: String,
    pub event: String,
    pub detail: String,
}

/// Take the next number of a repository's shared number space.
pub async fn next_number(pool: &Pool, repo_id: i64) -> sqlx::Result<i64> {
    let mut tx = super::begin_write(pool).await?;
    sqlx::query("INSERT INTO numbers (repo_id, next) VALUES ($1, 1) ON CONFLICT DO NOTHING").bind(repo_id).execute(&mut *tx).await?;
    let n: i64 = sqlx::query_scalar("SELECT next FROM numbers WHERE repo_id = $1").bind(repo_id).fetch_one(&mut *tx).await?;
    sqlx::query("UPDATE numbers SET next = next + 1 WHERE repo_id = $1").bind(repo_id).execute(&mut *tx).await?;
    tx.commit().await?;
    Ok(n)
}

pub struct NewProposal<'a> {
    pub repo_id: i64,
    pub title: &'a str,
    pub body: &'a str,
    pub author_id: Option<i64>,
    pub author: &'a str,
    pub draft: bool,
    pub target: &'a str,
    pub source_kind: &'a str,
    pub source_repo_id: Option<i64>,
    pub source_bookmark: &'a str,
    pub source_changes: &'a str,
}

pub async fn create(pool: &Pool, p: NewProposal<'_>) -> sqlx::Result<ProposalRow> {
    let number = next_number(pool, p.repo_id).await?;
    let now = now_ms();
    sqlx::query_as(
        "INSERT INTO proposals (repo_id, number, title, body, author_id, author, state, target, source_kind, source_repo_id, source_bookmark, source_changes, created_ms, updated_ms) \
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) RETURNING *",
    )
    .bind(p.repo_id)
    .bind(number)
    .bind(p.title)
    .bind(p.body)
    .bind(p.author_id)
    .bind(p.author)
    .bind(if p.draft { "draft" } else { "open" })
    .bind(p.target)
    .bind(p.source_kind)
    .bind(p.source_repo_id)
    .bind(p.source_bookmark)
    .bind(p.source_changes)
    .bind(now)
    .bind(now)
    .fetch_one(pool)
    .await
}

pub async fn get(pool: &Pool, repo_id: i64, number: i64) -> sqlx::Result<Option<ProposalRow>> {
    sqlx::query_as("SELECT * FROM proposals WHERE repo_id = $1 AND number = $2").bind(repo_id).bind(number).fetch_optional(pool).await
}

pub async fn list(pool: &Pool, repo_id: i64, states: &[&str]) -> sqlx::Result<Vec<ProposalRow>> {
    let all: Vec<ProposalRow> =
        sqlx::query_as("SELECT * FROM proposals WHERE repo_id = $1 ORDER BY number DESC").bind(repo_id).fetch_all(pool).await?;
    Ok(all.into_iter().filter(|p| states.is_empty() || states.contains(&p.state.as_str())).collect())
}

/// Open proposals of every repository, for the front page.
pub async fn open_for_author(pool: &Pool, author_id: i64) -> sqlx::Result<Vec<ProposalRow>> {
    sqlx::query_as("SELECT * FROM proposals WHERE author_id = $1 AND state IN ('open', 'draft') ORDER BY updated_ms DESC")
        .bind(author_id)
        .fetch_all(pool)
        .await
}

pub async fn set_projection(
    pool: &Pool,
    id: i64,
    state: &str,
    heads: &str,
    target_state: &str,
    changes: &str,
    conflicted: bool,
) -> sqlx::Result<()> {
    sqlx::query("UPDATE proposals SET projected_state = $1, projected_heads = $2, projected_target = $3, projected_changes = $4, conflicted = $5 WHERE id = $6")
        .bind(state)
        .bind(heads)
        .bind(target_state)
        .bind(changes)
        .bind(conflicted)
        .bind(id)
        .execute(pool)
        .await?;
    Ok(())
}

pub async fn set_state(pool: &Pool, id: i64, state: &str, landed_state: &str) -> sqlx::Result<()> {
    sqlx::query("UPDATE proposals SET state = $1, landed_state = $2, updated_ms = $3 WHERE id = $4")
        .bind(state)
        .bind(landed_state)
        .bind(now_ms())
        .bind(id)
        .execute(pool)
        .await?;
    if state == "closed" || state == "landed" {
        super::issues::finished(pool, "proposals", id).await?;
    }
    Ok(())
}

/// Mark a proposal landed, with who landed it and how.
pub async fn set_landed(pool: &Pool, id: i64, landed_state: &str, by: &str, via: &str) -> sqlx::Result<()> {
    let now = now_ms();
    sqlx::query(
        "UPDATE proposals SET state = 'landed', landed_state = $1, landed_by = $2, landed_via = $3, landed_ms = $4, updated_ms = $5 WHERE id = $6",
    )
    .bind(landed_state)
    .bind(by)
    .bind(via)
    .bind(now)
    .bind(now)
    .bind(id)
    .execute(pool)
    .await?;
    super::issues::finished(pool, "proposals", id).await
}

pub async fn edit(pool: &Pool, id: i64, title: &str, body: &str, target: &str) -> sqlx::Result<()> {
    sqlx::query("UPDATE proposals SET title = $1, body = $2, target = $3, updated_ms = $4 WHERE id = $5")
        .bind(title)
        .bind(body)
        .bind(target)
        .bind(now_ms())
        .bind(id)
        .execute(pool)
        .await?;
    Ok(())
}

pub async fn touch(pool: &Pool, id: i64) -> sqlx::Result<()> {
    sqlx::query("UPDATE proposals SET updated_ms = $1 WHERE id = $2").bind(now_ms()).bind(id).execute(pool).await?;
    Ok(())
}

pub async fn comments(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<CommentRow>> {
    sqlx::query_as("SELECT * FROM proposal_comments WHERE proposal_id = $1 ORDER BY created_ms, id").bind(proposal_id).fetch_all(pool).await
}

pub async fn add_comment(
    pool: &Pool,
    proposal_id: i64,
    author_id: Option<i64>,
    author: &str,
    body: &str,
    path: &str,
    anchor: Option<(&str, i64)>,
) -> sqlx::Result<CommentRow> {
    let row = sqlx::query_as(
        "INSERT INTO proposal_comments (proposal_id, author_id, author, body, path, anchor_change, anchor_index, created_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *",
    )
    .bind(proposal_id)
    .bind(author_id)
    .bind(author)
    .bind(body)
    .bind(path)
    .bind(anchor.map(|a| a.0).unwrap_or(""))
    .bind(anchor.map(|a| a.1).unwrap_or(0))
    .bind(now_ms())
    .fetch_one(pool)
    .await?;
    touch(pool, proposal_id).await?;
    Ok(row)
}

/// A conversation comment an AI assistant (`via`) wrote for `author`,
/// who asked it.
pub async fn add_comment_via(
    pool: &Pool,
    proposal_id: i64,
    author_id: i64,
    author: &str,
    body: &str,
    via: &str,
) -> sqlx::Result<CommentRow> {
    let row = sqlx::query_as(
        "INSERT INTO proposal_comments (proposal_id, author_id, author, body, path, anchor_change, anchor_index, created_ms, via) VALUES ($1, $2, $3, $4, '', '', 0, $5, $6) RETURNING *",
    )
    .bind(proposal_id)
    .bind(author_id)
    .bind(author)
    .bind(body)
    .bind(now_ms())
    .bind(via)
    .fetch_one(pool)
    .await?;
    touch(pool, proposal_id).await?;
    Ok(row)
}

pub async fn set_comment_resolved(pool: &Pool, id: i64, resolved: bool) -> sqlx::Result<()> {
    sqlx::query("UPDATE proposal_comments SET resolved = $1 WHERE id = $2").bind(resolved).bind(id).execute(pool).await?;
    Ok(())
}

pub async fn reviews(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<ReviewRow>> {
    sqlx::query_as("SELECT * FROM proposal_reviews WHERE proposal_id = $1 ORDER BY created_ms, id").bind(proposal_id).fetch_all(pool).await
}

pub async fn add_review(pool: &Pool, proposal_id: i64, author_id: i64, author: &str, verdict: &str, body: &str) -> sqlx::Result<ReviewRow> {
    add_review_via(pool, proposal_id, author_id, author, verdict, body, "").await
}

/// A review answered by an AI assistant (`via`) for `author`, who asked.
pub async fn add_review_via(
    pool: &Pool,
    proposal_id: i64,
    author_id: i64,
    author: &str,
    verdict: &str,
    body: &str,
    via: &str,
) -> sqlx::Result<ReviewRow> {
    let row = sqlx::query_as(
        "INSERT INTO proposal_reviews (proposal_id, author_id, author, verdict, body, created_ms, via) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *",
    )
    .bind(proposal_id)
    .bind(author_id)
    .bind(author)
    .bind(verdict)
    .bind(body)
    .bind(now_ms())
    .bind(via)
    .fetch_one(pool)
    .await?;
    touch(pool, proposal_id).await?;
    Ok(row)
}

pub async fn events(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<EventRow>> {
    sqlx::query_as("SELECT id, at_ms, actor, event, detail FROM proposal_events WHERE proposal_id = $1 ORDER BY at_ms, id")
        .bind(proposal_id)
        .fetch_all(pool)
        .await
}

/// Whether change `hash` (its short form) already references it (#318):
/// a change is recorded once, whichever bookmarks it is pushed on.
pub async fn referenced_by(pool: &Pool, proposal_id: i64, hash: &str) -> sqlx::Result<bool> {
    let n: i64 = sqlx::query_scalar(
        "SELECT COUNT(*) FROM proposal_events WHERE proposal_id = $1 AND event = 'referenced by change' AND (detail = $2 OR detail LIKE $3)",
    )
    .bind(proposal_id)
    .bind(hash)
    .bind(format!("{hash} %"))
    .fetch_one(pool)
    .await?;
    Ok(n > 0)
}

pub async fn add_event(pool: &Pool, proposal_id: i64, actor: &str, event: &str, detail: &str) -> sqlx::Result<()> {
    sqlx::query("INSERT INTO proposal_events (proposal_id, at_ms, actor, event, detail) VALUES ($1, $2, $3, $4, $5)")
        .bind(proposal_id)
        .bind(now_ms())
        .bind(actor)
        .bind(event)
        .bind(detail)
        .execute(pool)
        .await?;
    Ok(())
}

/// Landing requirements of a repository.
#[derive(Clone, Copy, Debug, Default, FromRow)]
pub struct Requirements {
    pub required_approvals: i64,
    pub require_owners: bool,
    pub allow_conflicts: bool,
}

pub async fn requirements(pool: &Pool, repo_id: i64) -> sqlx::Result<Requirements> {
    sqlx::query_as("SELECT required_approvals, require_owners, allow_conflicts FROM repositories WHERE id = $1")
        .bind(repo_id)
        .fetch_one(pool)
        .await
}

pub async fn set_requirements(pool: &Pool, repo_id: i64, r: Requirements) -> sqlx::Result<()> {
    sqlx::query("UPDATE repositories SET required_approvals = $1, require_owners = $2, allow_conflicts = $3 WHERE id = $4")
        .bind(r.required_approvals)
        .bind(r.require_owners)
        .bind(r.allow_conflicts)
        .bind(repo_id)
        .execute(pool)
        .await?;
    Ok(())
}

// ------------------------------------------------------- review requests

/// Ask an account to review a proposal; false when it was already asked.
pub async fn request_review(pool: &Pool, proposal_id: i64, account_id: i64, by: &str) -> sqlx::Result<bool> {
    let r = sqlx::query(
        "INSERT INTO proposal_review_requests (proposal_id, account_id, requested_by, requested_ms) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING",
    )
    .bind(proposal_id)
    .bind(account_id)
    .bind(by)
    .bind(now_ms())
    .execute(pool)
    .await?;
    Ok(r.rows_affected() == 1)
}

/// Withdraw a request, or mark it answered; false when there was none.
pub async fn unrequest_review(pool: &Pool, proposal_id: i64, account_id: i64) -> sqlx::Result<bool> {
    let r = sqlx::query("DELETE FROM proposal_review_requests WHERE proposal_id = $1 AND account_id = $2")
        .bind(proposal_id)
        .bind(account_id)
        .execute(pool)
        .await?;
    Ok(r.rows_affected() == 1)
}

/// The usernames asked to review a proposal and not yet reviewing, in the
/// order they were asked.
pub async fn review_requests(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<String>> {
    sqlx::query_scalar(
        "SELECT a.username FROM proposal_review_requests r JOIN accounts a ON a.id = r.account_id \
         WHERE r.proposal_id = $1 ORDER BY r.requested_ms, a.username",
    )
    .bind(proposal_id)
    .fetch_all(pool)
    .await
}

/// Set, or with `by` empty clear, landing when checks pass (#261).
pub async fn set_auto_land(pool: &Pool, id: i64, by: &str) -> sqlx::Result<()> {
    sqlx::query("UPDATE proposals SET auto_land_by = $1, auto_land_ms = $2 WHERE id = $3")
        .bind(by)
        .bind((!by.is_empty()).then(now_ms))
        .bind(id)
        .execute(pool)
        .await?;
    Ok(())
}

/// A repository's open proposals set to land when their checks pass, on
/// projected state `state`.
pub async fn auto_landing(pool: &Pool, repo_id: i64, state: &str) -> sqlx::Result<Vec<ProposalRow>> {
    sqlx::query_as(
        "SELECT * FROM proposals WHERE repo_id = $1 AND state = 'open' AND auto_land_by != '' AND projected_state = $2 ORDER BY number",
    )
    .bind(repo_id)
    .bind(state)
    .fetch_all(pool)
    .await
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! The `proposals`, `proposal_comments`, `proposal_reviews` and
2		//! `proposal_events` tables, and the per-repository number space.
3
4		use super::{now_ms, Pool};
5		use sqlx::FromRow;
6
7		#[derive(Clone, Debug, Default, FromRow)]
8		pub struct ProposalRow {
9		pub id: i64,
10		pub repo_id: i64,
11		pub number: i64,
12		pub title: String,
13		pub body: String,
14		pub author_id: Option<i64>,
15		pub author: String,
16		pub state: String,
17		pub target: String,
18		pub source_kind: String,
19		pub source_repo_id: Option<i64>,
20		pub source_bookmark: String,
21		pub source_changes: String,
22		pub projected_state: String,
23		pub projected_heads: String,
24		pub projected_target: String,
25		pub projected_changes: String,
26		pub conflicted: bool,
27		pub landed_state: String,
28		pub landed_by: String,
29		pub landed_via: String,
30		pub landed_ms: i64,
31		pub created_ms: i64,
32		pub updated_ms: i64,
33		/// Who set it to land when its checks pass (#261); empty when off.
34		#[sqlx(default)]
35		pub auto_land_by: String,
36		#[sqlx(default)]
37		pub auto_land_ms: Option<i64>,
38		}
39
40		impl ProposalRow {
41	11×	pub fn projected_heads(&self) -> Vec<String> {
42	14×	self.projected_heads.split(',').filter(\|s\| !s.is_empty()).map(String::from).collect()
43	11×	}
44
45	41×	pub fn projected_changes(&self) -> Vec<String> {
46	41×	self.projected_changes.split(',').filter(\|s\| !s.is_empty()).map(String::from).collect()
47	41×	}
48
49	0×	pub fn source_changes(&self) -> Vec<String> {
50	0×	self.source_changes.split(',').filter(\|s\| !s.is_empty()).map(String::from).collect()
51	0×	}
52
53	1235×	pub fn is_open(&self) -> bool {
54	1235×	self.state == "open" \|\| self.state == "draft"
55	1235×	}
56		}
57
58		#[derive(Clone, Debug, FromRow)]
59		pub struct CommentRow {
60		pub id: i64,
61		pub proposal_id: i64,
62		pub author_id: Option<i64>,
63		pub author: String,
64		pub body: String,
65		pub path: String,
66		pub anchor_change: String,
67		pub anchor_index: i64,
68		pub resolved: bool,
69		pub created_ms: i64,
70		/// The AI assistant that wrote it for the author (migration 0066),
71		/// empty for the author's own comment.
72		#[sqlx(default)]
73		pub via: String,
74		}
75
76		#[derive(Clone, Debug, FromRow)]
77		pub struct ReviewRow {
78		pub id: i64,
79		pub proposal_id: i64,
80		/// `None` once the author's account was deleted (its name stays).
81		pub author_id: Option<i64>,
82		pub author: String,
83		pub verdict: String,
84		pub body: String,
85		pub created_ms: i64,
86		/// The AI assistant that answered for the author (migration 0036),
87		/// empty for the author's own review.
88		#[sqlx(default)]
89		pub via: String,
90		}
91
92		#[derive(Clone, Debug, FromRow)]
93		pub struct EventRow {
94		pub id: i64,
95		pub at_ms: i64,
96		pub actor: String,
97		pub event: String,
98		pub detail: String,
99		}
100
101		/// Take the next number of a repository's shared number space.
102	117×	pub async fn next_number(pool: &Pool, repo_id: i64) -> sqlx::Result<i64> {
103	117×	let mut tx = super::begin_write(pool).await?;
104	117×	sqlx::query("INSERT INTO numbers (repo_id, next) VALUES ($1, 1) ON CONFLICT DO NOTHING").bind(repo_id).execute(&mut *tx).await?;
105	117×	let n: i64 = sqlx::query_scalar("SELECT next FROM numbers WHERE repo_id = $1").bind(repo_id).fetch_one(&mut *tx).await?;
106	117×	sqlx::query("UPDATE numbers SET next = next + 1 WHERE repo_id = $1").bind(repo_id).execute(&mut *tx).await?;
107	117×	tx.commit().await?;
108	117×	Ok(n)
109	117×	}
110
111		pub struct NewProposal<'a> {
112		pub repo_id: i64,
113		pub title: &'a str,
114		pub body: &'a str,
115		pub author_id: Option<i64>,
116		pub author: &'a str,
117		pub draft: bool,
118		pub target: &'a str,
119		pub source_kind: &'a str,
120		pub source_repo_id: Option<i64>,
121		pub source_bookmark: &'a str,
122		pub source_changes: &'a str,
123		}
124
125	48×	pub async fn create(pool: &Pool, p: NewProposal<'_>) -> sqlx::Result<ProposalRow> {
126	48×	let number = next_number(pool, p.repo_id).await?;
127	48×	let now = now_ms();
128	48×	sqlx::query_as(
129	48×	"INSERT INTO proposals (repo_id, number, title, body, author_id, author, state, target, source_kind, source_repo_id, source_bookmark, source_changes, created_ms, updated_ms) \
130	48×	VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) RETURNING *",
131		)
132	48×	.bind(p.repo_id)
133	48×	.bind(number)
134	48×	.bind(p.title)
135	48×	.bind(p.body)
136	48×	.bind(p.author_id)
137	48×	.bind(p.author)
138	48×	.bind(if p.draft { "draft" } else { "open" })
139	48×	.bind(p.target)
140	48×	.bind(p.source_kind)
141	48×	.bind(p.source_repo_id)
142	48×	.bind(p.source_bookmark)
143	48×	.bind(p.source_changes)
144	48×	.bind(now)
145	48×	.bind(now)
146	48×	.fetch_one(pool)
147	48×	.await
148	48×	}
149
150	311×	pub async fn get(pool: &Pool, repo_id: i64, number: i64) -> sqlx::Result<Option<ProposalRow>> {
151	311×	sqlx::query_as("SELECT * FROM proposals WHERE repo_id = $1 AND number = $2").bind(repo_id).bind(number).fetch_optional(pool).await
152	311×	}
153
154	788×	pub async fn list(pool: &Pool, repo_id: i64, states: &[&str]) -> sqlx::Result<Vec<ProposalRow>> {
155	788×	let all: Vec<ProposalRow> =
156	788×	sqlx::query_as("SELECT * FROM proposals WHERE repo_id = $1 ORDER BY number DESC").bind(repo_id).fetch_all(pool).await?;
157	788×	Ok(all.into_iter().filter(\|p\| states.is_empty() \|\| states.contains(&p.state.as_str())).collect())
158	788×	}
159
160		/// Open proposals of every repository, for the front page.
161	0×	pub async fn open_for_author(pool: &Pool, author_id: i64) -> sqlx::Result<Vec<ProposalRow>> {
162	0×	sqlx::query_as("SELECT * FROM proposals WHERE author_id = $1 AND state IN ('open', 'draft') ORDER BY updated_ms DESC")
163	0×	.bind(author_id)
164	0×	.fetch_all(pool)
165	0×	.await
166	0×	}
167
168	159×	pub async fn set_projection(
169	159×	pool: &Pool,
170	159×	id: i64,
171	159×	state: &str,
172	159×	heads: &str,
173	159×	target_state: &str,
174	159×	changes: &str,
175	159×	conflicted: bool,
176	159×	) -> sqlx::Result<()> {
177	159×	sqlx::query("UPDATE proposals SET projected_state = $1, projected_heads = $2, projected_target = $3, projected_changes = $4, conflicted = $5 WHERE id = $6")
178	159×	.bind(state)
179	159×	.bind(heads)
180	159×	.bind(target_state)
181	159×	.bind(changes)
182	159×	.bind(conflicted)
183	159×	.bind(id)
184	159×	.execute(pool)
185	159×	.await?;
186	159×	Ok(())
187	159×	}
188
189	9×	pub async fn set_state(pool: &Pool, id: i64, state: &str, landed_state: &str) -> sqlx::Result<()> {
190	9×	sqlx::query("UPDATE proposals SET state = $1, landed_state = $2, updated_ms = $3 WHERE id = $4")
191	9×	.bind(state)
192	9×	.bind(landed_state)
193	9×	.bind(now_ms())
194	9×	.bind(id)
195	9×	.execute(pool)
196	9×	.await?;
197	9×	if state == "closed" \|\| state == "landed" {
198	3×	super::issues::finished(pool, "proposals", id).await?;
199	6×	}
200	9×	Ok(())
201	9×	}
202
203		/// Mark a proposal landed, with who landed it and how.
204	23×	pub async fn set_landed(pool: &Pool, id: i64, landed_state: &str, by: &str, via: &str) -> sqlx::Result<()> {
205	23×	let now = now_ms();
206	23×	sqlx::query(
207	23×	"UPDATE proposals SET state = 'landed', landed_state = $1, landed_by = $2, landed_via = $3, landed_ms = $4, updated_ms = $5 WHERE id = $6",
208	23×	)
209	23×	.bind(landed_state)
210	23×	.bind(by)
211	23×	.bind(via)
212	23×	.bind(now)
213	23×	.bind(now)
214	23×	.bind(id)
215	23×	.execute(pool)
216	23×	.await?;
217	23×	super::issues::finished(pool, "proposals", id).await
218	23×	}
219
220	6×	pub async fn edit(pool: &Pool, id: i64, title: &str, body: &str, target: &str) -> sqlx::Result<()> {
221	6×	sqlx::query("UPDATE proposals SET title = $1, body = $2, target = $3, updated_ms = $4 WHERE id = $5")
222	6×	.bind(title)
223	6×	.bind(body)
224	6×	.bind(target)
225	6×	.bind(now_ms())
226	6×	.bind(id)
227	6×	.execute(pool)
228	6×	.await?;
229	6×	Ok(())
230	6×	}
231
232	11×	pub async fn touch(pool: &Pool, id: i64) -> sqlx::Result<()> {
233	11×	sqlx::query("UPDATE proposals SET updated_ms = $1 WHERE id = $2").bind(now_ms()).bind(id).execute(pool).await?;
234	11×	Ok(())
235	11×	}
236
237	80×	pub async fn comments(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<CommentRow>> {
238	80×	sqlx::query_as("SELECT * FROM proposal_comments WHERE proposal_id = $1 ORDER BY created_ms, id").bind(proposal_id).fetch_all(pool).await
239	80×	}
240
241	4×	pub async fn add_comment(
242	4×	pool: &Pool,
243	4×	proposal_id: i64,
244	4×	author_id: Option<i64>,
245	4×	author: &str,
246	4×	body: &str,
247	4×	path: &str,
248	4×	anchor: Option<(&str, i64)>,
249	4×	) -> sqlx::Result<CommentRow> {
250	4×	let row = sqlx::query_as(
251	4×	"INSERT INTO proposal_comments (proposal_id, author_id, author, body, path, anchor_change, anchor_index, created_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *",
252		)
253	4×	.bind(proposal_id)
254	4×	.bind(author_id)
255	4×	.bind(author)
256	4×	.bind(body)
257	4×	.bind(path)
258	4×	.bind(anchor.map(\|a\| a.0).unwrap_or(""))
259	4×	.bind(anchor.map(\|a\| a.1).unwrap_or(0))
260	4×	.bind(now_ms())
261	4×	.fetch_one(pool)
262	4×	.await?;
263	4×	touch(pool, proposal_id).await?;
264	4×	Ok(row)
265	4×	}
266
267		/// A conversation comment an AI assistant (`via`) wrote for `author`,
268		/// who asked it.
269	1×	pub async fn add_comment_via(
270	1×	pool: &Pool,
271	1×	proposal_id: i64,
272	1×	author_id: i64,
273	1×	author: &str,
274	1×	body: &str,
275	1×	via: &str,
276	1×	) -> sqlx::Result<CommentRow> {
277	1×	let row = sqlx::query_as(
278	1×	"INSERT INTO proposal_comments (proposal_id, author_id, author, body, path, anchor_change, anchor_index, created_ms, via) VALUES ($1, $2, $3, $4, '', '', 0, $5, $6) RETURNING *",
279	1×	)
280	1×	.bind(proposal_id)
281	1×	.bind(author_id)
282	1×	.bind(author)
283	1×	.bind(body)
284	1×	.bind(now_ms())
285	1×	.bind(via)
286	1×	.fetch_one(pool)
287	1×	.await?;
288	1×	touch(pool, proposal_id).await?;
289	1×	Ok(row)
290	1×	}
291
292	0×	pub async fn set_comment_resolved(pool: &Pool, id: i64, resolved: bool) -> sqlx::Result<()> {
293	0×	sqlx::query("UPDATE proposal_comments SET resolved = $1 WHERE id = $2").bind(resolved).bind(id).execute(pool).await?;
294	0×	Ok(())
295	0×	}
296
297	150×	pub async fn reviews(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<ReviewRow>> {
298	150×	sqlx::query_as("SELECT * FROM proposal_reviews WHERE proposal_id = $1 ORDER BY created_ms, id").bind(proposal_id).fetch_all(pool).await
299	150×	}
300
301	5×	pub async fn add_review(pool: &Pool, proposal_id: i64, author_id: i64, author: &str, verdict: &str, body: &str) -> sqlx::Result<ReviewRow> {
302	5×	add_review_via(pool, proposal_id, author_id, author, verdict, body, "").await
303	5×	}
304
305		/// A review answered by an AI assistant (`via`) for `author`, who asked.
306	6×	pub async fn add_review_via(
307	6×	pool: &Pool,
308	6×	proposal_id: i64,
309	6×	author_id: i64,
310	6×	author: &str,
311	6×	verdict: &str,
312	6×	body: &str,
313	6×	via: &str,
314	6×	) -> sqlx::Result<ReviewRow> {
315	6×	let row = sqlx::query_as(
316	6×	"INSERT INTO proposal_reviews (proposal_id, author_id, author, verdict, body, created_ms, via) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *",
317	6×	)
318	6×	.bind(proposal_id)
319	6×	.bind(author_id)
320	6×	.bind(author)
321	6×	.bind(verdict)
322	6×	.bind(body)
323	6×	.bind(now_ms())
324	6×	.bind(via)
325	6×	.fetch_one(pool)
326	6×	.await?;
327	6×	touch(pool, proposal_id).await?;
328	6×	Ok(row)
329	6×	}
330
331	79×	pub async fn events(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<EventRow>> {
332	79×	sqlx::query_as("SELECT id, at_ms, actor, event, detail FROM proposal_events WHERE proposal_id = $1 ORDER BY at_ms, id")
333	79×	.bind(proposal_id)
334	79×	.fetch_all(pool)
335	79×	.await
336	79×	}
337
338		/// Whether change `hash` (its short form) already references it (#318):
339		/// a change is recorded once, whichever bookmarks it is pushed on.
340	1×	pub async fn referenced_by(pool: &Pool, proposal_id: i64, hash: &str) -> sqlx::Result<bool> {
341	1×	let n: i64 = sqlx::query_scalar(
342	1×	"SELECT COUNT(*) FROM proposal_events WHERE proposal_id = $1 AND event = 'referenced by change' AND (detail = $2 OR detail LIKE $3)",
343	1×	)
344	1×	.bind(proposal_id)
345	1×	.bind(hash)
346	1×	.bind(format!("{hash} %"))
347	1×	.fetch_one(pool)
348	1×	.await?;
349	1×	Ok(n > 0)
350	1×	}
351
352	98×	pub async fn add_event(pool: &Pool, proposal_id: i64, actor: &str, event: &str, detail: &str) -> sqlx::Result<()> {
353	98×	sqlx::query("INSERT INTO proposal_events (proposal_id, at_ms, actor, event, detail) VALUES ($1, $2, $3, $4, $5)")
354	98×	.bind(proposal_id)
355	98×	.bind(now_ms())
356	98×	.bind(actor)
357	98×	.bind(event)
358	98×	.bind(detail)
359	98×	.execute(pool)
360	98×	.await?;
361	98×	Ok(())
362	98×	}
363
364		/// Landing requirements of a repository.
365		#[derive(Clone, Copy, Debug, Default, FromRow)]
366		pub struct Requirements {
367		pub required_approvals: i64,
368		pub require_owners: bool,
369		pub allow_conflicts: bool,
370		}
371
372	285×	pub async fn requirements(pool: &Pool, repo_id: i64) -> sqlx::Result<Requirements> {
373	285×	sqlx::query_as("SELECT required_approvals, require_owners, allow_conflicts FROM repositories WHERE id = $1")
374	285×	.bind(repo_id)
375	285×	.fetch_one(pool)
376	285×	.await
377	285×	}
378
379	4×	pub async fn set_requirements(pool: &Pool, repo_id: i64, r: Requirements) -> sqlx::Result<()> {
380	4×	sqlx::query("UPDATE repositories SET required_approvals = $1, require_owners = $2, allow_conflicts = $3 WHERE id = $4")
381	4×	.bind(r.required_approvals)
382	4×	.bind(r.require_owners)
383	4×	.bind(r.allow_conflicts)
384	4×	.bind(repo_id)
385	4×	.execute(pool)
386	4×	.await?;
387	4×	Ok(())
388	4×	}
389
390		// ------------------------------------------------------- review requests
391
392		/// Ask an account to review a proposal; false when it was already asked.
393	3×	pub async fn request_review(pool: &Pool, proposal_id: i64, account_id: i64, by: &str) -> sqlx::Result<bool> {
394	3×	let r = sqlx::query(
395	3×	"INSERT INTO proposal_review_requests (proposal_id, account_id, requested_by, requested_ms) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING",
396	3×	)
397	3×	.bind(proposal_id)
398	3×	.bind(account_id)
399	3×	.bind(by)
400	3×	.bind(now_ms())
401	3×	.execute(pool)
402	3×	.await?;
403	3×	Ok(r.rows_affected() == 1)
404	3×	}
405
406		/// Withdraw a request, or mark it answered; false when there was none.
407	6×	pub async fn unrequest_review(pool: &Pool, proposal_id: i64, account_id: i64) -> sqlx::Result<bool> {
408	6×	let r = sqlx::query("DELETE FROM proposal_review_requests WHERE proposal_id = $1 AND account_id = $2")
409	6×	.bind(proposal_id)
410	6×	.bind(account_id)
411	6×	.execute(pool)
412	6×	.await?;
413	6×	Ok(r.rows_affected() == 1)
414	6×	}
415
416		/// The usernames asked to review a proposal and not yet reviewing, in the
417		/// order they were asked.
418	121×	pub async fn review_requests(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<String>> {
419	121×	sqlx::query_scalar(
420	121×	"SELECT a.username FROM proposal_review_requests r JOIN accounts a ON a.id = r.account_id \
421	121×	WHERE r.proposal_id = $1 ORDER BY r.requested_ms, a.username",
422	121×	)
423	121×	.bind(proposal_id)
424	121×	.fetch_all(pool)
425	121×	.await
426	121×	}
427
428		/// Set, or with `by` empty clear, landing when checks pass (#261).
429	6×	pub async fn set_auto_land(pool: &Pool, id: i64, by: &str) -> sqlx::Result<()> {
430	6×	sqlx::query("UPDATE proposals SET auto_land_by = $1, auto_land_ms = $2 WHERE id = $3")
431	6×	.bind(by)
432	6×	.bind((!by.is_empty()).then(now_ms))
433	6×	.bind(id)
434	6×	.execute(pool)
435	6×	.await?;
436	6×	Ok(())
437	6×	}
438
439		/// A repository's open proposals set to land when their checks pass, on
440		/// projected state `state`.
441	727×	pub async fn auto_landing(pool: &Pool, repo_id: i64, state: &str) -> sqlx::Result<Vec<ProposalRow>> {
442	727×	sqlx::query_as(
443	727×	"SELECT * FROM proposals WHERE repo_id = $1 AND state = 'open' AND auto_land_by != '' AND projected_state = $2 ORDER BY number",
444	727×	)
445	727×	.bind(repo_id)
446	727×	.bind(state)
447	727×	.fetch_all(pool)
448	727×	.await
449	727×	}

Coverage / crates/hub/src/db/proposals.rs 95.1%

Keyboard