OXYGENHUB
# 9a065bc0ce33 oxygenhub / crates / hub / src / api / mod.rs
59.1 KiB · Rust · last changed Required checks over the API: GET and PUT /repos/{o}/{n}/checks/required (admins, the whole list, audited) 1 month ago source blame history raw
b64e2537 Andy McCall ↶ 1 
//! The JSON API (hub spec §12.1) under `/api/v1`: bearer tokens, RFC 7807
2 
//! problems, the same shapes as `oxy --json` where one exists. Reads need
3 
//! `repo:read` (anonymous for public repositories); writes the scope named
4 
//! on each handler.
d23464c0 Andy McCall ↶ 5
b64e2537 Andy McCall ↶ 6 
use crate::auth::{self, Access, Role};
7 
use crate::db::{self, accounts::Account};
d23464c0 Andy McCall ↶ 8 
use crate::repos::{view, RepoError, RepoName};
b64e2537 Andy McCall ↶ 9 
use crate::Shared;
10 
use axum::extract::{Path, Query, State};
11 
use axum::http::{HeaderMap, StatusCode};
d23464c0 Andy McCall ↶ 12 
use axum::response::{IntoResponse, Response};
b64e2537 Andy McCall ↶ 13 
use axum::routing::{get, post};
d23464c0 Andy McCall ↶ 14 
use axum::{Json, Router};
b64e2537 Andy McCall ↶ 15 
use hub_api::*;
16 
use serde::Deserialize;
d23464c0 Andy McCall ↶ 17
ef20fdc1 Andy McCall ↶ 18 
mod projects;
19
d23464c0 Andy McCall ↶ 20 
pub fn router() -> Router<Shared> {
21 
    Router::new()
42fa9554 Andy McCall ↶ 22 
        .route("/flow/claim", post(crate::flow::claim))
23 
        .route("/flow/jobs/{id}/log", post(crate::flow::log))
24 
        .route("/flow/jobs/{id}/finish", post(crate::flow::finish))
ef20fdc1 Andy McCall ↶ 25 
        .route("/projects/{owner}", get(projects::list).post(projects::create))
26 
        .route("/projects/{owner}/{number}", get(projects::board).patch(projects::edit))
27 
        .route("/projects/{owner}/{number}/cards", post(projects::add_card))
28 
        .route("/projects/{owner}/{number}/cards/{id}", axum::routing::patch(projects::move_card).delete(projects::remove_card))
b64e2537 Andy McCall ↶ 29 
        .route("/user", get(me))
42a0ba4b Andy McCall ↶ 30 
        .route("/notifications", get(notifications))
31 
        .route("/notifications/read", post(notifications_read_all))
32 
        .route("/notifications/{id}/read", post(notification_read))
b64e2537 Andy McCall ↶ 33 
        .route("/users/{name}", get(user))
34 
        .route("/orgs/{name}", get(org))
35 
        .route("/search", get(search))
36 
        .route("/repos", get(list_repos).post(create_repo))
d23464c0 Andy McCall ↶ 37 
        .route("/repos/{owner}/{name}", get(get_repo))
38 
        .route("/repos/{owner}/{name}/bookmarks", get(bookmarks))
39 
        .route("/repos/{owner}/{name}/tags", get(tags))
b64e2537 Andy McCall ↶ 40 
        .route("/repos/{owner}/{name}/history/{r}", get(history))
41 
        .route("/repos/{owner}/{name}/changes/{hash}", get(change))
42 
        .route("/repos/{owner}/{name}/tree/{r}", get(tree_root))
43 
        .route("/repos/{owner}/{name}/tree/{r}/{*path}", get(tree))
44 
        .route("/repos/{owner}/{name}/file/{r}/{*path}", get(file))
45 
        .route("/repos/{owner}/{name}/blame/{r}/{*path}", get(blame))
46 
        .route("/repos/{owner}/{name}/conflicts", get(conflicts))
47 
        .route("/repos/{owner}/{name}/trust", get(trust))
48 
        .route("/repos/{owner}/{name}/pushes", get(pushes))
49 
        .route("/repos/{owner}/{name}/proposals", get(proposals).post(create_proposal))
de505df5 Andy McCall ↶ 50 
        .route("/repos/{owner}/{name}/proposals/{number}", get(proposal))
b64e2537 Andy McCall ↶ 51 
        .route("/repos/{owner}/{name}/proposals/{number}/comments", get(proposal_comments).post(proposal_comment))
52 
        .route("/repos/{owner}/{name}/proposals/{number}/reviews", get(proposal_reviews).post(proposal_review))
53 
        .route("/repos/{owner}/{name}/proposals/{number}/checks", get(proposal_checks))
3f02e5ea Andy McCall ↶ 54 
        .route("/repos/{owner}/{name}/proposals/{number}/files", get(proposal_files))
55 
        .route("/repos/{owner}/{name}/proposals/{number}/content/{side}/{*path}", get(proposal_content))
b64e2537 Andy McCall ↶ 56 
        .route("/repos/{owner}/{name}/issues", get(issues).post(create_issue))
76f262e1 Andy McCall ↶ 57 
        .route("/repos/{owner}/{name}/issues/{number}", get(issue).post(issue_state).patch(issue_edit))
b64e2537 Andy McCall ↶ 58 
        .route("/repos/{owner}/{name}/issues/{number}/comments", get(issue_comments).post(issue_comment))
76f262e1 Andy McCall ↶ 59 
        .route("/repos/{owner}/{name}/labels", get(labels).post(create_label))
60 
        .route("/repos/{owner}/{name}/labels/{label}", axum::routing::delete(delete_label))
b64e2537 Andy McCall ↶ 61 
        .route("/repos/{owner}/{name}/milestones", get(milestones))
62 
        .route("/repos/{owner}/{name}/hooks", get(hooks).post(create_hook))
63 
        .route("/repos/{owner}/{name}/hooks/{id}/delete", post(delete_hook))
64 
        .route("/repos/{owner}/{name}/checks", post(post_check))
961c10be Andy McCall ↶ 65 
        .route("/repos/{owner}/{name}/checks/required", get(required_checks).put(set_required_checks))
b64e2537 Andy McCall ↶ 66 
        .route("/repos/{owner}/{name}/checks/{state}", get(checks_for_state))
3f4b0ea6 Andy McCall ↶ 67 
        .route("/repos/{owner}/{name}/releases", get(releases).post(create_release))
68 
        .route("/repos/{owner}/{name}/releases/{tag}/assets", post(upload_asset))
69 
}
70
71 
async fn releases(
72 
    State(app): State<Shared>,
73 
    headers: HeaderMap,
74 
    Path((owner, name)): Path<(String, String)>,
75 
) -> Result<Json<Vec<Release>>, ApiError> {
76 
    let c = caller(&app, &headers).await?;
77 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
78 
    Ok(Json(crate::web::releases::api_views(&app, &repo, &row).await?))
79 
}
80
81 
async fn create_release(
82 
    State(app): State<Shared>,
83 
    headers: HeaderMap,
84 
    Path((owner, name)): Path<(String, String)>,
85 
    Json(body): Json<NewRelease>,
86 
) -> Result<(StatusCode, Json<Release>), ApiError> {
87 
    let c = caller(&app, &headers).await?;
88 
    let me = c.require("repo:write")?.clone();
89 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
90 
    crate::web::releases::create_release(&app, &repo, &row, &me, &body.tag, &body.title, body.notes, body.prerelease)
91 
        .await
92 
        .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
93 
    let r = crate::web::releases::api_views(&app, &repo, &row)
94 
        .await?
95 
        .into_iter()
96 
        .find(|r| r.tag == body.tag)
97 
        .ok_or_else(|| not_found("no such release"))?;
98 
    Ok((StatusCode::CREATED, Json(r)))
99 
}
100
101 
#[derive(Deserialize)]
102 
struct AssetQuery {
103 
    name: String,
de505df5 Andy McCall ↶ 104 
}
105
3f4b0ea6 Andy McCall ↶ 106 
/// `POST …/releases/{tag}/assets?name=file.tar.gz` with the file as the body.
107 
async fn upload_asset(
108 
    State(app): State<Shared>,
109 
    headers: HeaderMap,
110 
    Path((owner, name, tag)): Path<(String, String, String)>,
111 
    Query(q): Query<AssetQuery>,
112 
    body: axum::body::Bytes,
113 
) -> Result<(StatusCode, Json<Release>), ApiError> {
114 
    let c = caller(&app, &headers).await?;
115 
    c.require("repo:write")?;
116 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
117 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
118 
    let ct = headers.get(axum::http::header::CONTENT_TYPE).and_then(|v| v.to_str().ok()).unwrap_or("application/octet-stream").to_string();
119 
    crate::web::releases::store_asset(&app, r.id, &q.name, &ct, &body).await.map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
120 
    let r = crate::web::releases::api_views(&app, &repo, &row)
121 
        .await?
122 
        .into_iter()
123 
        .find(|r| r.tag == tag)
124 
        .ok_or_else(|| not_found("no such release"))?;
125 
    Ok((StatusCode::CREATED, Json(r)))
126 
}
127
42fa9554 Andy McCall ↶ 128 
pub struct ApiError(pub StatusCode, pub String);
b64e2537 Andy McCall ↶ 129
130 
impl IntoResponse for ApiError {
131 
    fn into_response(self) -> Response {
132 
        let body = Problem { status: self.0.as_u16(), title: self.0.canonical_reason().unwrap_or("error").into(), detail: self.1 };
133 
        (self.0, [("content-type", "application/problem+json")], Json(body)).into_response()
de505df5 Andy McCall ↶ 134 
    }
b64e2537 Andy McCall ↶ 135 
}
136
137 
impl From<RepoError> for ApiError {
138 
    fn from(e: RepoError) -> ApiError {
139 
        match e {
140 
            RepoError::NotFound => not_found("no such repository"),
141 
            RepoError::Oxy(oxy_core::repo::RepoError::Msg(m)) => ApiError(StatusCode::NOT_FOUND, m),
142 
            other => ApiError(StatusCode::INTERNAL_SERVER_ERROR, other.to_string()),
143 
        }
144 
    }
145 
}
146
147 
impl From<sqlx::Error> for ApiError {
148 
    fn from(e: sqlx::Error) -> ApiError {
149 
        ApiError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
150 
    }
151 
}
152
ef20fdc1 Andy McCall ↶ 153 
pub(crate) fn not_found(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 154 
    ApiError(StatusCode::NOT_FOUND, what.into())
155 
}
156
ef20fdc1 Andy McCall ↶ 157 
pub(crate) fn forbidden(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 158 
    ApiError(StatusCode::FORBIDDEN, what.into())
159 
}
160
161 
/// Who calls: the account behind a bearer token, with the token's scopes.
162 
pub struct Caller {
163 
    pub account: Option<Account>,
164 
    pub scopes: Vec<String>,
165 
    pub site: bool,
166 
}
167
168 
impl Caller {
169 
    fn has(&self, scope: &str) -> bool {
170 
        self.site
171 
            || self.scopes.iter().any(|s| {
172 
                s == scope
173 
                    || (scope == "repo:read" && (s == "repo:write" || s == "repo:admin"))
174 
                    || (scope == "repo:write" && s == "repo:admin")
175 
            })
176 
    }
177
178 
    fn require(&self, scope: &str) -> Result<&Account, ApiError> {
179 
        if !self.has(scope) {
180 
            return Err(forbidden(&format!("this token lacks the {scope} scope")));
181 
        }
182 
        self.account.as_ref().ok_or_else(|| ApiError(StatusCode::UNAUTHORIZED, "a personal access token is required".into()))
183 
    }
184 
}
185
186 
pub async fn caller(app: &Shared, headers: &HeaderMap) -> Result<Caller, ApiError> {
187 
    let Some(t) = oxy_server::bearer_token(headers) else { return Ok(Caller { account: None, scopes: vec![], site: false }) };
188 
    if app.config.auth.push_tokens.iter().any(|x| auth::mac_equal(x, t)) {
189 
        let admin = db::accounts::accounts(&app.db).await?.into_iter().find(|a| a.is_admin);
190 
        return Ok(Caller { account: admin, scopes: vec!["repo:admin".into(), "user:read".into(), "checks:write".into()], site: true });
191 
    }
192 
    let token = db::accounts::token_by_hash(&app.db, &auth::token_hash(t)).await?;
de505df5 Andy McCall ↶ 193 
    match token {
b64e2537 Andy McCall ↶ 194 
        Some(tok) if !tok.expired(db::now_ms()) => {
195 
            let account = db::accounts::account_by_id(&app.db, tok.account_id).await?.filter(|a| !a.banned);
196 
            db::accounts::touch_token(&app.db, tok.id).await.ok();
197 
            Ok(Caller { account, scopes: tok.scope_list().iter().map(|s| s.to_string()).collect(), site: false })
198 
        }
de505df5 Andy McCall ↶ 199 
        _ => Err(ApiError(StatusCode::UNAUTHORIZED, "unknown or expired token".into())),
200 
    }
201 
}
202
b64e2537 Andy McCall ↶ 203 
fn repository(app: &Shared, r: &db::repos::RepoRow) -> Repository {
204 
    Repository {
205 
        owner: r.owner.clone(),
206 
        name: r.name.clone(),
207 
        description: r.description.clone(),
208 
        default_bookmark: r.default_bookmark.clone(),
209 
        visibility: r.visibility(),
210 
        created_ms: r.created_ms,
211 
        updated_ms: r.updated_ms,
212 
        clone_url: format!("{}/{}/{}", app.config.base_url(), r.owner, r.name),
213 
    }
214 
}
215
216 
/// A repository the caller may reach with `access`, else 404.
217 
async fn reach(
de505df5 Andy McCall ↶ 218 
    app: &Shared,
b64e2537 Andy McCall ↶ 219 
    c: &Caller,
de505df5 Andy McCall ↶ 220 
    owner: &str,
221 
    name: &str,
b64e2537 Andy McCall ↶ 222 
    access: Access,
223 
) -> Result<(RepoName, db::repos::RepoRow, Role), ApiError> {
224 
    let repo = RepoName::new(owner, name).ok_or_else(|| not_found("no such repository"))?;
225 
    let row = db::repos::get(&app.db, owner, name).await?.ok_or_else(|| not_found("no such repository"))?;
226 
    let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
227 
    if !auth::roles::allows(role, access) {
228 
        return Err(not_found("no such repository"));
229 
    }
230 
    Ok((repo, row, role.unwrap_or(Role::Read)))
231 
}
232
233 
fn summary(c: &view::ChangeView) -> ChangeSummary {
234 
    ChangeSummary {
235 
        hash: c.hash.clone(),
236 
        message: if c.body.is_empty() { c.title.clone() } else { format!("{}\n\n{}", c.title, c.body) },
237 
        author: Author {
238 
            name: c.author.name.clone(),
239 
            email: c.author.email.clone(),
240 
            key: c.author.key.clone(),
241 
            account: c.author.account.clone(),
242 
        },
243 
        when_ms: c.when_ms,
244 
        deps: c.deps.clone(),
245 
        head: c.head,
246 
        signature: match &c.signature {
247 
            view::SigView::Unsigned => Signature::Unsigned,
248 
            view::SigView::Valid { key, sealed, revoked, .. } => Signature::Valid { key: key.clone(), sealed: *sealed, revoked: *revoked },
249 
            view::SigView::Invalid(why) => Signature::Invalid { reason: why.clone() },
250 
        },
251 
    }
252 
}
253
254 
// ---------------------------------------------------------------- accounts
255
256 
async fn me(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<User>, ApiError> {
257 
    let c = caller(&app, &headers).await?;
258 
    let a = c.require("user:read")?;
259 
    Ok(Json(user_of(&app, a).await?))
260 
}
261
42a0ba4b Andy McCall ↶ 262 
#[derive(Deserialize)]
263 
struct InboxQuery {
264 
    #[serde(default)]
265 
    limit: Option<i64>,
266 
}
267
268 
/// The caller's inbox; reading and clearing it needs `user:read`, since
269 
/// it touches nothing but the caller's own notifications.
270 
async fn notifications(
271 
    State(app): State<Shared>,
272 
    headers: HeaderMap,
273 
    Query(q): Query<InboxQuery>,
274 
) -> Result<Json<hub_api::Inbox>, ApiError> {
275 
    let c = caller(&app, &headers).await?;
276 
    let a = c.require("user:read")?;
277 
    let limit = q.limit.unwrap_or(50).clamp(1, 200);
278 
    let base = app.config.base_url().trim_end_matches('/').to_string();
279 
    let items = db::notify::inbox(&app.db, a.id, limit)
280 
        .await?
281 
        .into_iter()
282 
        .map(|n| hub_api::Notification {
283 
            id: n.id,
284 
            at_ms: n.at_ms,
285 
            kind: n.kind,
286 
            title: n.title,
287 
            url: if n.url.starts_with('/') { format!("{base}{}", n.url) } else { n.url },
288 
            actor: n.actor,
289 
            read: n.read,
290 
        })
291 
        .collect();
292 
    Ok(Json(hub_api::Inbox { unread: db::notify::unread(&app.db, a.id).await?, items }))
293 
}
294
295 
async fn notification_read(State(app): State<Shared>, headers: HeaderMap, Path(id): Path<i64>) -> Result<StatusCode, ApiError> {
296 
    let c = caller(&app, &headers).await?;
297 
    let a = c.require("user:read")?;
298 
    db::notify::mark_read(&app.db, a.id, Some(id)).await?;
299 
    Ok(StatusCode::NO_CONTENT)
300 
}
301
302 
async fn notifications_read_all(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
303 
    let c = caller(&app, &headers).await?;
304 
    let a = c.require("user:read")?;
305 
    db::notify::mark_read(&app.db, a.id, None).await?;
306 
    Ok(StatusCode::NO_CONTENT)
307 
}
308
b64e2537 Andy McCall ↶ 309 
async fn user_of(app: &Shared, a: &Account) -> Result<User, ApiError> {
310 
    let keys = db::accounts::identities_of(&app.db, a.id).await?.into_iter().map(|i| i.key).collect();
311 
    Ok(User { username: a.username.clone(), display_name: a.display_name.clone(), is_admin: a.is_admin, keys, created_ms: a.created_ms })
312 
}
313
314 
async fn user(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<User>, ApiError> {
315 
    let a = db::accounts::account_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such account"))?;
316 
    Ok(Json(user_of(&app, &a).await?))
317 
}
318
319 
async fn org(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<Organisation>, ApiError> {
320 
    let o = db::accounts::org_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such organisation"))?;
321 
    let members = db::accounts::org_members(&app.db, o.id).await?.into_iter().map(|(a, _)| a.username).collect();
322 
    Ok(Json(Organisation { name: o.name, display_name: o.display_name, description: o.description, members }))
323 
}
324
325 
#[derive(Deserialize)]
326 
struct SearchQuery {
327 
    q: String,
328 
}
329
330 
async fn search(
331 
    State(app): State<Shared>,
332 
    headers: HeaderMap,
333 
    Query(q): Query<SearchQuery>,
334 
) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
335 
    let c = caller(&app, &headers).await?;
336 
    let mut out = Vec::new();
337 
    for h in db::notify::search(&app.db, &q.q, None, 50).await? {
338 
        let Some(row) = db::repos::get_by_id(&app.db, h.repo_id).await? else { continue };
339 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
340 
        if !auth::roles::allows(role, Access::Read) {
341 
            continue;
342 
        }
343 
        out.push(
344 
            serde_json::json!({ "kind": h.kind, "repository": row.slug(), "number": h.number, "title": h.title, "snippet": h.snippet }),
345 
        );
346 
    }
347 
    Ok(Json(out))
348 
}
349
350 
// ------------------------------------------------------------ repositories
351
352 
async fn list_repos(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Repository>>, ApiError> {
353 
    let c = caller(&app, &headers).await?;
354 
    let mut out = Vec::new();
355 
    for r in db::repos::list(&app.db).await? {
356 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &r).await?;
357 
        if auth::roles::allows(role, Access::Read) {
358 
            out.push(repository(&app, &r));
359 
        }
de505df5 Andy McCall ↶ 360 
    }
b64e2537 Andy McCall ↶ 361 
    Ok(Json(out))
362 
}
363
364 
async fn create_repo(
365 
    State(app): State<Shared>,
366 
    headers: HeaderMap,
367 
    Json(body): Json<NewRepository>,
368 
) -> Result<(StatusCode, Json<Repository>), ApiError> {
369 
    let c = caller(&app, &headers).await?;
370 
    let me = c.require("repo:admin")?;
371 
    let name = RepoName::new(&body.owner, &body.name).ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "invalid owner or name".into()))?;
372 
    if !auth::roles::may_create_under(&app.db, me, &name.owner).await? {
373 
        return Err(forbidden("you cannot create repositories under that owner"));
374 
    }
375 
    if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() || app.repos.exists(&name) {
376 
        return Err(ApiError(StatusCode::CONFLICT, "that repository exists".into()));
377 
    }
378 
    app.repos.create(&name, None)?;
379 
    let row = db::repos::create(&app.db, &name.owner, &name.name, &body.description, body.visibility).await?;
380 
    db::accounts::audit(&app.db, Some(me), "repo.created", &name.to_string(), "api").await.ok();
381 
    Ok((StatusCode::CREATED, Json(repository(&app, &row))))
382 
}
383
384 
async fn get_repo(
385 
    State(app): State<Shared>,
386 
    headers: HeaderMap,
387 
    Path((owner, name)): Path<(String, String)>,
388 
) -> Result<Json<Repository>, ApiError> {
389 
    let c = caller(&app, &headers).await?;
390 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
391 
    Ok(Json(repository(&app, &row)))
392 
}
393
394 
async fn bookmarks(
395 
    State(app): State<Shared>,
396 
    headers: HeaderMap,
397 
    Path((owner, name)): Path<(String, String)>,
398 
) -> Result<Json<Vec<Bookmark>>, ApiError> {
399 
    let c = caller(&app, &headers).await?;
400 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
401 
    let default = row.default_bookmark.clone();
402 
    let list = app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await?;
403 
    Ok(Json(list.into_iter().map(|b| Bookmark { name: b.name, heads: b.heads, changes: b.changes, default: b.default }).collect()))
404 
}
405
406 
async fn tags(
407 
    State(app): State<Shared>,
408 
    headers: HeaderMap,
409 
    Path((owner, name)): Path<(String, String)>,
410 
) -> Result<Json<Vec<Tag>>, ApiError> {
411 
    let c = caller(&app, &headers).await?;
412 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
413 
    let list = app.repos.read(&repo, |r, _| view::tags(r)).await?;
414 
    Ok(Json(list.into_iter().map(|t| Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer }).collect()))
415 
}
416
417 
#[derive(Deserialize)]
418 
struct HistoryQuery {
419 
    path: Option<String>,
420 
    offset: Option<usize>,
421 
    limit: Option<usize>,
422 
}
423
424 
async fn history(
425 
    State(app): State<Shared>,
426 
    headers: HeaderMap,
427 
    Path((owner, name, r)): Path<(String, String, String)>,
428 
    Query(q): Query<HistoryQuery>,
429 
) -> Result<Json<History>, ApiError> {
430 
    let c = caller(&app, &headers).await?;
431 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
432 
    let (offset, limit) = (q.offset.unwrap_or(0), q.limit.unwrap_or(50).min(500));
433 
    let h = app
434 
        .repos
435 
        .read(&repo, move |repo, cache| {
436 
            let target = view::resolve(repo, cache, &r)?;
437 
            view::history(repo, cache, target, q.path.as_deref(), offset, limit)
438 
        })
439 
        .await?;
440 
    let mut entries = h.entries;
441 
    crate::web::attribute(&app, &mut entries.iter_mut().collect::<Vec<_>>()).await;
442 
    Ok(Json(History {
443 
        reference: h.target.label,
444 
        heads: h.target.heads.iter().map(|x| x.to_hex()).collect(),
445 
        total: h.total,
446 
        offset: h.offset,
447 
        changes: entries.iter().map(summary).collect(),
448 
    }))
449 
}
450
451 
async fn change(
452 
    State(app): State<Shared>,
453 
    headers: HeaderMap,
454 
    Path((owner, name, hash)): Path<(String, String, String)>,
455 
) -> Result<Json<ChangeDetail>, ApiError> {
456 
    let c = caller(&app, &headers).await?;
457 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
458 
    let d = app
459 
        .repos
460 
        .read(&repo, move |repo, cache| {
461 
            let h = view::resolve_change(repo, cache, &hash)?;
462 
            view::change(repo, cache, &h)
463 
        })
464 
        .await?;
465 
    let mut v = d.view;
466 
    crate::web::attribute(&app, &mut [&mut v]).await;
467 
    let files = crate::web::history::render_files(&d.files, &d.bases)
468 
        .into_iter()
469 
        .map(|f| FileChange { path: f.path, kind: f.kind, from: f.from, added: f.added, removed: f.removed })
470 
        .collect();
471 
    Ok(Json(ChangeDetail {
472 
        body: v.body.clone(),
473 
        change: summary(&v),
474 
        dependents: d.dependents.iter().map(|x| x.hash.clone()).collect(),
475 
        in_bookmarks: d.in_bookmarks,
476 
        in_tags: d.in_tags,
477 
        files,
478 
    }))
479 
}
480
481 
fn entry(e: &view::Entry) -> TreeEntry {
482 
    TreeEntry {
483 
        name: e.name.clone(),
484 
        path: e.path.clone(),
485 
        kind: match e.kind {
486 
            view::EntryKind::Dir => "dir",
487 
            view::EntryKind::File => "file",
488 
            view::EntryKind::Symlink => "symlink",
489 
            view::EntryKind::Subrepo => "subrepo",
490 
        }
491 
        .into(),
492 
        exec: e.exec,
493 
        size: e.size,
494 
        conflicted: e.conflicted,
495 
    }
496 
}
497
498 
async fn tree_root(
499 
    State(app): State<Shared>,
500 
    headers: HeaderMap,
501 
    Path((owner, name, r)): Path<(String, String, String)>,
502 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
503 
    tree(State(app), headers, Path((owner, name, r, String::new()))).await
504 
}
505
506 
async fn tree(
507 
    State(app): State<Shared>,
508 
    headers: HeaderMap,
509 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
510 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
511 
    let c = caller(&app, &headers).await?;
512 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
513 
    let t = app
514 
        .repos
515 
        .read(&repo, move |repo, cache| {
516 
            let target = view::resolve(repo, cache, &r)?;
517 
            view::tree(repo, cache, target, &path)
518 
        })
519 
        .await?;
520 
    Ok(Json(t.entries.iter().map(entry).collect()))
521 
}
522
523 
async fn file(
524 
    State(app): State<Shared>,
525 
    headers: HeaderMap,
526 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
527 
) -> Result<Response, ApiError> {
528 
    let c = caller(&app, &headers).await?;
529 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
530 
    let limit = app.config.limits.render_limit.0;
531 
    let f = app
532 
        .repos
533 
        .read(&repo, move |repo, cache| {
534 
            let target = view::resolve(repo, cache, &r)?;
535 
            view::file(repo, cache, target, &path, limit)
536 
        })
537 
        .await?;
538 
    Ok(crate::web::raw(f.bytes, &f.name, false))
539 
}
540
541 
async fn blame(
542 
    State(app): State<Shared>,
543 
    headers: HeaderMap,
544 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
545 
) -> Result<Json<Vec<BlameLine>>, ApiError> {
546 
    let c = caller(&app, &headers).await?;
547 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
548 
    let limit = app.config.limits.render_limit.0;
549 
    let b = app
550 
        .repos
551 
        .read(&repo, move |repo, cache| {
552 
            let target = view::resolve(repo, cache, &r)?;
553 
            view::blame(repo, cache, target, &path, limit)
554 
        })
555 
        .await?;
556 
    Ok(Json(
557 
        b.lines
558 
            .into_iter()
559 
            .map(|l| BlameLine {
560 
                line: l.line,
561 
                change: l.hash.to_hex(),
562 
                index: l.index,
563 
                author: l.author,
564 
                when_ms: l.when_ms,
565 
                text: String::from_utf8_lossy(&l.text).into_owned(),
566 
            })
567 
            .collect(),
568 
    ))
569 
}
570
571 
async fn conflicts(
572 
    State(app): State<Shared>,
573 
    headers: HeaderMap,
574 
    Path((owner, name)): Path<(String, String)>,
575 
) -> Result<Json<Vec<Conflict>>, ApiError> {
576 
    let c = caller(&app, &headers).await?;
577 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
578 
    let list = app.repos.read(&repo, view::conflicts).await?;
579 
    Ok(Json(
580 
        list.into_iter()
581 
            .map(|c| Conflict {
582 
                bookmark: c.bookmark,
583 
                path: c.path,
584 
                kind: c.kind,
585 
                contributors: c.contributors.iter().map(|x| x.hash.clone()).collect(),
586 
            })
587 
            .collect(),
588 
    ))
589 
}
590
591 
async fn trust(
592 
    State(app): State<Shared>,
593 
    headers: HeaderMap,
594 
    Path((owner, name)): Path<(String, String)>,
595 
) -> Result<Json<Trust>, ApiError> {
596 
    let c = caller(&app, &headers).await?;
597 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
598 
    let key = app.hub_key.key;
599 
    let t = app.repos.read(&repo, move |r, cache| view::trust(r, cache, &key)).await?;
600 
    Ok(Json(Trust {
601 
        policy: t.policy.map(|p| Policy {
602 
            serial: p.serial,
603 
            expires_ms: p.expires_ms,
604 
            roots: p.roots.iter().map(|k| k.key.clone()).collect(),
605 
            root_threshold: p.root_threshold,
606 
            rules: p
607 
                .rules
608 
                .iter()
609 
                .map(|r| Rule {
610 
                    pattern: r.pattern.clone(),
611 
                    keys: r.keys.iter().map(|k| k.key.clone()).collect(),
612 
                    threshold: r.threshold,
613 
                    require: r.require.clone(),
614 
                    allow_conflicts: r.allow_conflicts,
615 
                })
616 
                .collect(),
617 
        }),
618 
        signed: t.verification.signed,
619 
        sealed: t.verification.sealed,
620 
        unsigned: t.verification.unsigned,
621 
        invalid: t.verification.invalid.iter().map(|(h, _)| h.clone()).collect(),
622 
        hub_key: t.hub_key,
623 
    }))
624 
}
625
626 
async fn pushes(
627 
    State(app): State<Shared>,
628 
    headers: HeaderMap,
629 
    Path((owner, name)): Path<(String, String)>,
630 
) -> Result<Json<Vec<Push>>, ApiError> {
631 
    let c = caller(&app, &headers).await?;
632 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
633 
    let rows = db::repos::pushes(&app.db, row.id, 200).await?;
634 
    Ok(Json(
635 
        rows.into_iter()
636 
            .map(|p| Push {
637 
                at_ms: p.at_ms,
638 
                pusher: p.pusher,
639 
                reference: p.reference,
640 
                ok: p.ok,
641 
                reason: p.reason,
642 
                old_state: p.old_state,
643 
                new_state: p.new_state,
644 
                heads: p.heads,
645 
                changes: p.changes,
646 
            })
647 
            .collect(),
648 
    ))
de505df5 Andy McCall ↶ 649 
}
650
b64e2537 Andy McCall ↶ 651 
// --------------------------------------------------------------- proposals
652
de505df5 Andy McCall ↶ 653 
async fn proposals(
654 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 655 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 656 
    Path((owner, name)): Path<(String, String)>,
b64e2537 Andy McCall ↶ 657 
) -> Result<Json<Vec<Proposal>>, ApiError> {
658 
    let c = caller(&app, &headers).await?;
659 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
de505df5 Andy McCall ↶ 660 
    let mut out = Vec::new();
661 
    for p in db::proposals::list(&app.db, row.id, &["open", "draft"]).await? {
662 
        let loaded = crate::web::proposals::load(&app, &repo, p).await?;
663 
        let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
664 
        out.push(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await);
665 
    }
666 
    Ok(Json(out))
667 
}
668
669 
async fn proposal(
670 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 671 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 672 
    Path((owner, name, number)): Path<(String, String, i64)>,
b64e2537 Andy McCall ↶ 673 
) -> Result<Json<Proposal>, ApiError> {
674 
    let c = caller(&app, &headers).await?;
675 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
676 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
de505df5 Andy McCall ↶ 677 
    let source_url = match p.source_repo_id {
678 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
679 
        None => None,
680 
    };
681 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
682 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
683 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
d23464c0 Andy McCall ↶ 684 
}
685
3f02e5ea Andy McCall ↶ 686 
/// The files a proposal changes (hub spec §12.1).
687 
async fn proposal_files(
688 
    State(app): State<Shared>,
689 
    headers: HeaderMap,
690 
    Path((owner, name, number)): Path<(String, String, i64)>,
691 
) -> Result<Json<Vec<hub_api::ProposalFile>>, ApiError> {
692 
    let c = caller(&app, &headers).await?;
693 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
694 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
695 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
696 
    Ok(Json(
697 
        loaded
698 
            .files
699 
            .iter()
700 
            .map(|f| hub_api::ProposalFile {
701 
                path: f.path.clone(),
702 
                from: f.from.clone(),
703 
                kind: f.kind.clone(),
704 
                added: f.added,
705 
                removed: f.removed,
706 
            })
707 
            .collect(),
708 
    ))
709 
}
710
711 
/// One file's bytes on a side of a proposal: `base` is the target's
712 
/// state, `head` the projected state. 404 when the file does not exist
713 
/// on that side.
714 
async fn proposal_content(
715 
    State(app): State<Shared>,
716 
    headers: HeaderMap,
717 
    Path((owner, name, number, side, path)): Path<(String, String, i64, String, String)>,
718 
) -> Result<Response, ApiError> {
719 
    let c = caller(&app, &headers).await?;
720 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
721 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
722 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
723 
    let heads = match side.as_str() {
724 
        "base" => loaded.target_heads,
725 
        "head" => loaded.heads,
726 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "the side is base or head".into())),
727 
    };
728 
    let limit = app.config.limits.render_limit.0;
729 
    let target = view::RefTarget { label: side, kind: view::RefKind::Change, heads };
730 
    let f = app.repos.read(&repo, move |repo, cache| view::file(repo, cache, target, &path, limit)).await?;
731 
    Ok(crate::web::raw(f.bytes, &f.name, false))
732 
}
733
b64e2537 Andy McCall ↶ 734 
async fn create_proposal(
735 
    State(app): State<Shared>,
736 
    headers: HeaderMap,
737 
    Path((owner, name)): Path<(String, String)>,
738 
    Json(body): Json<NewProposal>,
739 
) -> Result<(StatusCode, Json<Proposal>), ApiError> {
740 
    let c = caller(&app, &headers).await?;
741 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
742 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
743 
    let created =
744 
        crate::web::proposals::open_proposal(&app, &repo, &row, &me, &body.title, &body.body, &body.target, &body.source, body.draft)
745 
            .await
746 
            .map_err(|e| ApiError(StatusCode::BAD_REQUEST, e))?;
747 
    let loaded = crate::web::proposals::load(&app, &repo, created).await?;
748 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
749 
    Ok((StatusCode::CREATED, Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)))
750 
}
d23464c0 Andy McCall ↶ 751
b64e2537 Andy McCall ↶ 752 
fn comment_of(c: &db::proposals::CommentRow) -> Comment {
753 
    Comment {
754 
        id: c.id,
755 
        author: c.author.clone(),
756 
        body: c.body.clone(),
757 
        created_ms: c.created_ms,
758 
        path: if c.path.is_empty() { None } else { Some(c.path.clone()) },
759 
        anchor: if c.anchor_change.is_empty() {
760 
            None
761 
        } else {
762 
            Some(Atom { change: c.anchor_change.clone(), index: c.anchor_index as u32 })
763 
        },
764 
        resolved: c.resolved,
d23464c0 Andy McCall ↶ 765 
    }
766 
}
767
b64e2537 Andy McCall ↶ 768 
async fn proposal_comments(
769 
    State(app): State<Shared>,
770 
    headers: HeaderMap,
771 
    Path((owner, name, number)): Path<(String, String, i64)>,
772 
) -> Result<Json<Vec<Comment>>, ApiError> {
773 
    let c = caller(&app, &headers).await?;
774 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
775 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
776 
    Ok(Json(db::proposals::comments(&app.db, p.id).await?.iter().map(comment_of).collect()))
777 
}
778
779 
async fn proposal_comment(
780 
    State(app): State<Shared>,
781 
    headers: HeaderMap,
782 
    Path((owner, name, number)): Path<(String, String, i64)>,
783 
    Json(body): Json<NewComment>,
784 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
785 
    let c = caller(&app, &headers).await?;
786 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
787 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
788 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
789 
    if body.body.trim().is_empty() {
790 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
791 
    }
3f4b0ea6 Andy McCall ↶ 792 
    let (repo, _) = (RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?, ());
793 
    let anchor = match (body.path.as_deref().map(|x| x.trim_matches('/')), body.line) {
794 
        (Some(path), Some(line)) if !path.is_empty() => {
795 
            let loaded = crate::web::proposals::load(&app, &repo, p.clone()).await?;
796 
            let (heads, file) = (loaded.heads.clone(), path.to_string());
797 
            let atom = app
798 
                .repos
799 
                .read(&repo, move |r, cache| {
800 
                    let projected = cache.load(r, &heads)?;
801 
                    Ok(crate::repos::proposals::atom_at(&projected, &file, line).map(|(h, i)| (h.to_hex(), i)))
802 
                })
803 
                .await?
804 
                .ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, format!("{path}:{line} is not a line of the projected state")))?;
805 
            Some((path.to_string(), atom))
806 
        }
807 
        _ => None,
808 
    };
809 
    let row_c = db::proposals::add_comment(
810 
        &app.db,
811 
        p.id,
812 
        Some(me.id),
813 
        &me.username,
814 
        body.body.trim(),
815 
        anchor.as_ref().map(|(path, _)| path.as_str()).unwrap_or(""),
816 
        anchor.as_ref().map(|(_, (h, i))| (h.as_str(), *i as i64)),
817 
    )
818 
    .await?;
b64e2537 Andy McCall ↶ 819 
    crate::notify::deliver(
820 
        &app,
821 
        crate::notify::Event {
822 
            kind: "proposal.comment",
823 
            title: format!("{owner}/{name}#{number}: {}", p.title),
824 
            url: format!("/{owner}/{name}/proposal/{number}"),
825 
            actor: &me,
826 
            repo_id: row.id,
827 
            thread: Some(("proposal", p.id)),
828 
            mention_text: &body.body,
829 
            direct: p.author_id.into_iter().collect(),
830 
        },
831 
    )
832 
    .await;
833 
    crate::hooks::emit(
834 
        &app,
835 
        &row,
836 
        "comment.proposal",
837 
        &me.username,
838 
        serde_json::json!({ "number": number, "comment": comment_of(&row_c) }),
839 
    )
840 
    .await;
841 
    Ok((StatusCode::CREATED, Json(comment_of(&row_c))))
842 
}
843
844 
async fn proposal_reviews(
845 
    State(app): State<Shared>,
846 
    headers: HeaderMap,
847 
    Path((owner, name, number)): Path<(String, String, i64)>,
848 
) -> Result<Json<Vec<Review>>, ApiError> {
849 
    let c = caller(&app, &headers).await?;
850 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
851 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
852 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
853 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
854 
    Ok(Json(
855 
        v.reviews
856 
            .into_iter()
857 
            .map(|r| Review {
858 
                id: r.row.id,
859 
                author: r.row.author,
860 
                verdict: r.row.verdict,
861 
                body: r.row.body,
862 
                sealed: r.sealed,
863 
                created_ms: r.row.created_ms,
864 
            })
865 
            .collect(),
866 
    ))
867 
}
868
869 
async fn proposal_review(
870 
    State(app): State<Shared>,
871 
    headers: HeaderMap,
872 
    Path((owner, name, number)): Path<(String, String, i64)>,
873 
    Json(body): Json<NewReview>,
874 
) -> Result<(StatusCode, Json<Review>), ApiError> {
875 
    let c = caller(&app, &headers).await?;
876 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
877 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
878 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
879 
    if !matches!(body.verdict.as_str(), "comment" | "changes" | "approve") {
880 
        return Err(ApiError(StatusCode::BAD_REQUEST, "verdict is comment, changes or approve".into()));
881 
    }
882 
    if body.verdict == "approve" && Some(me.id) == p.author_id {
883 
        return Err(forbidden("you cannot approve your own proposal"));
884 
    }
885 
    let r = db::proposals::add_review(&app.db, p.id, me.id, &me.username, &body.verdict, body.body.trim()).await?;
886 
    db::proposals::add_event(&app.db, p.id, &me.username, &format!("review.{}", body.verdict), "").await.ok();
887 
    crate::hooks::emit(&app, &row, "review", &me.username, serde_json::json!({ "number": number, "verdict": body.verdict })).await;
888 
    Ok((
889 
        StatusCode::CREATED,
890 
        Json(Review { id: r.id, author: r.author, verdict: r.verdict, body: r.body, sealed: false, created_ms: r.created_ms }),
891 
    ))
892 
}
893
894 
async fn proposal_checks(
895 
    State(app): State<Shared>,
896 
    headers: HeaderMap,
897 
    Path((owner, name, number)): Path<(String, String, i64)>,
898 
) -> Result<Json<Vec<Check>>, ApiError> {
899 
    let c = caller(&app, &headers).await?;
900 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
901 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
902 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
903 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await?.iter().map(check_of).collect()))
904 
}
905
906 
// ------------------------------------------------------------------ issues
907
908 
async fn issue_of(app: &Shared, row: &db::repos::RepoRow, i: &db::issues::IssueRow) -> Result<Issue, ApiError> {
909 
    let labels = db::issues::issue_labels(&app.db, i.id)
910 
        .await?
911 
        .into_iter()
912 
        .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
913 
        .collect();
914 
    let assignees = db::issues::assignees(&app.db, i.id).await?;
915 
    let milestone = match i.milestone_id {
916 
        Some(id) => db::issues::milestone(&app.db, id).await?.map(|m| m.title),
917 
        None => None,
918 
    };
919 
    let comments: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM issue_comments WHERE issue_id = ?").bind(i.id).fetch_one(&app.db).await?;
920 
    Ok(Issue {
921 
        number: i.number,
922 
        title: i.title.clone(),
923 
        body: i.body.clone(),
924 
        author: i.author.clone(),
925 
        state: i.state.clone(),
926 
        reason: i.reason.clone(),
927 
        labels,
928 
        assignees,
929 
        milestone,
930 
        comments,
931 
        locked: i.locked,
932 
        pinned: i.pinned,
933 
        created_ms: i.created_ms,
934 
        updated_ms: i.updated_ms,
935 
        closed_ms: i.closed_ms,
936 
        url: format!("{}/{}/issue/{}", app.config.base_url(), row.slug(), i.number),
937 
    })
938 
}
939
940 
#[derive(Deserialize)]
941 
struct IssuesQuery {
942 
    state: Option<String>,
943 
}
944
945 
async fn issues(
946 
    State(app): State<Shared>,
947 
    headers: HeaderMap,
948 
    Path((owner, name)): Path<(String, String)>,
949 
    Query(q): Query<IssuesQuery>,
950 
) -> Result<Json<Vec<Issue>>, ApiError> {
951 
    let c = caller(&app, &headers).await?;
952 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
953 
    let state = q.state.unwrap_or_else(|| "open".into());
954 
    let mut out = Vec::new();
955 
    for i in db::issues::list(&app.db, row.id).await? {
956 
        if state == "all" || i.state == state {
957 
            out.push(issue_of(&app, &row, &i).await?);
d23464c0 Andy McCall ↶ 958 
        }
959 
    }
b64e2537 Andy McCall ↶ 960 
    Ok(Json(out))
d23464c0 Andy McCall ↶ 961 
}
962
b64e2537 Andy McCall ↶ 963 
async fn create_issue(
964 
    State(app): State<Shared>,
965 
    headers: HeaderMap,
966 
    Path((owner, name)): Path<(String, String)>,
967 
    Json(body): Json<NewIssue>,
968 
) -> Result<(StatusCode, Json<Issue>), ApiError> {
969 
    let c = caller(&app, &headers).await?;
970 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
76f262e1 Andy McCall ↶ 971 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
b64e2537 Andy McCall ↶ 972 
    if body.title.trim().is_empty() {
973 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
d23464c0 Andy McCall ↶ 974 
    }
76f262e1 Andy McCall ↶ 975 
    let triage = !body.labels.is_empty() || !body.assignees.is_empty() || body.milestone.is_some();
976 
    if triage && role < Role::Triage {
977 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
978 
    }
979 
    // Check the names before anything is created.
980 
    resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
b64e2537 Andy McCall ↶ 981 
    let i = db::issues::create(
982 
        &app.db,
983 
        db::issues::NewIssue {
984 
            repo_id: row.id,
985 
            title: body.title.trim(),
986 
            body: body.body.trim(),
987 
            author_id: Some(me.id),
988 
            author: &me.username,
989 
        },
990 
    )
991 
    .await?;
992 
    db::issues::add_event(&app.db, i.id, &me.username, "opened", "").await.ok();
76f262e1 Andy McCall ↶ 993 
    if triage {
994 
        let t = resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
995 
        apply_triage(&app, &i, &me, t).await?;
996 
    }
997 
    let i = db::issues::get(&app.db, row.id, i.number).await?.unwrap_or(i);
b64e2537 Andy McCall ↶ 998 
    crate::web::issues::reindex(&app, row.id, &i).await;
999 
    let api = issue_of(&app, &row, &i).await?;
1000 
    crate::notify::deliver(
1001 
        &app,
1002 
        crate::notify::Event {
1003 
            kind: "issue.opened",
1004 
            title: format!("{owner}/{name}#{}: {}", i.number, i.title),
1005 
            url: format!("/{owner}/{name}/issue/{}", i.number),
1006 
            actor: &me,
1007 
            repo_id: row.id,
1008 
            thread: Some(("issue", i.id)),
1009 
            mention_text: &body.body,
1010 
            direct: vec![],
1011 
        },
1012 
    )
1013 
    .await;
1014 
    crate::hooks::emit(&app, &row, "issue.opened", &me.username, serde_json::json!({ "issue": api })).await;
1015 
    Ok((StatusCode::CREATED, Json(api)))
1016 
}
1017
1018 
async fn issue(
1019 
    State(app): State<Shared>,
1020 
    headers: HeaderMap,
1021 
    Path((owner, name, number)): Path<(String, String, i64)>,
1022 
) -> Result<Json<Issue>, ApiError> {
1023 
    let c = caller(&app, &headers).await?;
1024 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1025 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1026 
    Ok(Json(issue_of(&app, &row, &i).await?))
1027 
}
1028
1029 
async fn issue_state(
1030 
    State(app): State<Shared>,
1031 
    headers: HeaderMap,
1032 
    Path((owner, name, number)): Path<(String, String, i64)>,
1033 
    Json(body): Json<IssueStateChange>,
1034 
) -> Result<Json<Issue>, ApiError> {
1035 
    let c = caller(&app, &headers).await?;
1036 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1037 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1038 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1039 
    if role < Role::Triage && Some(me.id) != i.author_id {
1040 
        return Err(forbidden("only the author or triage may change the state"));
1041 
    }
1042 
    let (state, reason) = match body.state.as_str() {
1043 
        "closed" => ("closed", if body.reason == "not_planned" { "not_planned" } else { "completed" }),
1044 
        "open" => ("open", ""),
1045 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is open or closed".into())),
1046 
    };
1047 
    db::issues::set_state(&app.db, i.id, state, reason).await?;
1048 
    db::issues::add_event(&app.db, i.id, &me.username, if state == "closed" { "closed" } else { "reopened" }, "").await.ok();
1049 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
1050 
    let api = issue_of(&app, &row, &fresh).await?;
1051 
    crate::hooks::emit(
1052 
        &app,
1053 
        &row,
1054 
        if state == "closed" { "issue.closed" } else { "issue.reopened" },
1055 
        &me.username,
1056 
        serde_json::json!({ "issue": api }),
1057 
    )
1058 
    .await;
1059 
    Ok(Json(api))
1060 
}
1061
1062 
async fn issue_comments(
1063 
    State(app): State<Shared>,
1064 
    headers: HeaderMap,
1065 
    Path((owner, name, number)): Path<(String, String, i64)>,
1066 
) -> Result<Json<Vec<Comment>>, ApiError> {
1067 
    let c = caller(&app, &headers).await?;
1068 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1069 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1070 
    Ok(Json(
1071 
        db::issues::comments(&app.db, i.id)
1072 
            .await?
1073 
            .into_iter()
1074 
            .map(|c| Comment {
1075 
                id: c.id,
1076 
                author: c.author,
1077 
                body: c.body,
1078 
                created_ms: c.created_ms,
1079 
                path: None,
1080 
                anchor: None,
1081 
                resolved: false,
1082 
            })
1083 
            .collect(),
1084 
    ))
1085 
}
1086
1087 
async fn issue_comment(
1088 
    State(app): State<Shared>,
1089 
    headers: HeaderMap,
1090 
    Path((owner, name, number)): Path<(String, String, i64)>,
1091 
    Json(body): Json<NewComment>,
1092 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
1093 
    let c = caller(&app, &headers).await?;
1094 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1095 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1096 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1097 
    if i.locked && role < Role::Triage {
1098 
        return Err(forbidden("this issue is locked"));
1099 
    }
1100 
    if body.body.trim().is_empty() {
1101 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
1102 
    }
1103 
    let cm = db::issues::add_comment(&app.db, i.id, Some(me.id), &me.username, body.body.trim()).await?;
1104 
    crate::web::issues::reindex(&app, row.id, &i).await;
1105 
    crate::notify::deliver(
1106 
        &app,
1107 
        crate::notify::Event {
1108 
            kind: "issue.comment",
1109 
            title: format!("{owner}/{name}#{number}: {}", i.title),
1110 
            url: format!("/{owner}/{name}/issue/{number}"),
1111 
            actor: &me,
1112 
            repo_id: row.id,
1113 
            thread: Some(("issue", i.id)),
1114 
            mention_text: &body.body,
1115 
            direct: i.author_id.into_iter().collect(),
1116 
        },
1117 
    )
1118 
    .await;
1119 
    let api = Comment { id: cm.id, author: cm.author, body: cm.body, created_ms: cm.created_ms, path: None, anchor: None, resolved: false };
1120 
    crate::hooks::emit(&app, &row, "comment.issue", &me.username, serde_json::json!({ "number": number, "comment": api })).await;
1121 
    Ok((StatusCode::CREATED, Json(api)))
76f262e1 Andy McCall ↶ 1122 
}
1123
1124 
/// Labels, assignees and milestone named in a request, looked up.
1125 
struct Triage {
1126 
    labels: Option<Vec<db::issues::Label>>,
1127 
    assignees: Option<Vec<Account>>,
1128 
    /// `Some(None)` clears the milestone.
1129 
    milestone: Option<Option<db::issues::Milestone>>,
1130 
}
1131
1132 
async fn resolve_triage(
1133 
    app: &Shared,
1134 
    repo_id: i64,
1135 
    labels: Option<&[String]>,
1136 
    assignees: Option<&[String]>,
1137 
    milestone: Option<&str>,
1138 
) -> Result<Triage, ApiError> {
1139 
    let bad = |m: String| ApiError(StatusCode::BAD_REQUEST, m);
1140 
    let labels = match labels {
1141 
        Some(names) => {
1142 
            let mut out = Vec::new();
1143 
            for n in names {
1144 
                out.push(
1145 
                    db::issues::label_by_name(&app.db, repo_id, n.trim())
1146 
                        .await?
1147 
                        .ok_or_else(|| bad(format!("no label {n:?}; create it first")))?,
1148 
                );
1149 
            }
1150 
            Some(out)
1151 
        }
1152 
        None => None,
1153 
    };
1154 
    let assignees = match assignees {
1155 
        Some(names) => {
1156 
            let mut out = Vec::new();
1157 
            for n in names {
1158 
                out.push(db::accounts::account_by_name(&app.db, n.trim()).await?.ok_or_else(|| bad(format!("no account {n:?}")))?);
1159 
            }
1160 
            Some(out)
1161 
        }
1162 
        None => None,
1163 
    };
1164 
    let milestone = match milestone.map(str::trim) {
1165 
        None => None,
1166 
        Some("") => Some(None),
1167 
        Some(title) => Some(Some(
1168 
            db::issues::milestones(&app.db, repo_id)
1169 
                .await?
1170 
                .into_iter()
1171 
                .find(|m| m.title == title)
1172 
                .ok_or_else(|| bad(format!("no milestone {title:?}")))?,
1173 
        )),
1174 
    };
1175 
    Ok(Triage { labels, assignees, milestone })
1176 
}
1177
1178 
/// Make an issue's labels, assignees and milestone what `t` says, with
1179 
/// timeline events for what changed.
1180 
async fn apply_triage(app: &Shared, i: &db::issues::IssueRow, me: &Account, t: Triage) -> Result<(), ApiError> {
1181 
    if let Some(want) = t.labels {
1182 
        let have = db::issues::issue_labels(&app.db, i.id).await?;
1183 
        for l in &have {
1184 
            if !want.iter().any(|w| w.id == l.id) {
1185 
                db::issues::set_issue_label(&app.db, i.id, l.id, false).await?;
1186 
            }
1187 
        }
1188 
        for w in &want {
1189 
            if !have.iter().any(|l| l.id == w.id) {
1190 
                db::issues::set_issue_label(&app.db, i.id, w.id, true).await?;
1191 
            }
1192 
        }
1193 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
1194 
        db::issues::add_event(&app.db, i.id, &me.username, "set labels", &names.join(", ")).await.ok();
1195 
    }
1196 
    if let Some(want) = t.assignees {
1197 
        let have = db::issues::assignees(&app.db, i.id).await?;
1198 
        for name in &have {
1199 
            if !want.iter().any(|a| &a.username == name) {
1200 
                if let Some(a) = db::accounts::account_by_name(&app.db, name).await? {
1201 
                    db::issues::set_assignee(&app.db, i.id, a.id, false).await?;
1202 
                    db::issues::add_event(&app.db, i.id, &me.username, "unassigned", name).await.ok();
1203 
                }
1204 
            }
1205 
        }
1206 
        for a in &want {
1207 
            if !have.contains(&a.username) {
1208 
                db::issues::set_assignee(&app.db, i.id, a.id, true).await?;
1209 
                db::issues::add_event(&app.db, i.id, &me.username, "assigned", &a.username).await.ok();
1210 
            }
1211 
        }
1212 
    }
1213 
    if let Some(m) = t.milestone {
1214 
        db::issues::set_milestone(&app.db, i.id, m.as_ref().map(|m| m.id)).await?;
1215 
        db::issues::add_event(&app.db, i.id, &me.username, "set milestone", m.as_ref().map(|m| m.title.as_str()).unwrap_or("")).await.ok();
1216 
    }
1217 
    Ok(())
1218 
}
1219
1220 
/// `PATCH /repos/{o}/{n}/issues/{number}`.
1221 
async fn issue_edit(
1222 
    State(app): State<Shared>,
1223 
    headers: HeaderMap,
1224 
    Path((owner, name, number)): Path<(String, String, i64)>,
1225 
    Json(body): Json<IssueEdit>,
1226 
) -> Result<Json<Issue>, ApiError> {
1227 
    let c = caller(&app, &headers).await?;
1228 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1229 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1230 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1231 
    let text = body.title.is_some() || body.body.is_some();
1232 
    let triage = body.labels.is_some() || body.assignees.is_some() || body.milestone.is_some();
1233 
    if text && role < Role::Triage && Some(me.id) != i.author_id {
1234 
        return Err(forbidden("only the author or triage may edit the title and body"));
1235 
    }
1236 
    if triage && role < Role::Triage {
1237 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
1238 
    }
1239 
    if i.locked && role < Role::Triage {
1240 
        return Err(forbidden("this issue is locked"));
1241 
    }
1242 
    let t = resolve_triage(&app, row.id, body.labels.as_deref(), body.assignees.as_deref(), body.milestone.as_deref()).await?;
1243 
    if text {
1244 
        let title = body.title.as_deref().map(str::trim).unwrap_or(&i.title);
1245 
        if title.is_empty() {
1246 
            return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
1247 
        }
1248 
        db::issues::edit(&app.db, i.id, title, body.body.as_deref().unwrap_or(&i.body)).await?;
1249 
        db::issues::add_event(&app.db, i.id, &me.username, "edited", "").await.ok();
1250 
    }
1251 
    apply_triage(&app, &i, &me, t).await?;
1252 
    db::issues::touch(&app.db, i.id).await.ok();
1253 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
1254 
    crate::web::issues::reindex(&app, row.id, &fresh).await;
1255 
    let api = issue_of(&app, &row, &fresh).await?;
1256 
    crate::hooks::emit(&app, &row, "issue.edited", &me.username, serde_json::json!({ "issue": api })).await;
1257 
    Ok(Json(api))
1258 
}
1259
1260 
/// `POST /repos/{o}/{n}/labels` (triage).
1261 
async fn create_label(
1262 
    State(app): State<Shared>,
1263 
    headers: HeaderMap,
1264 
    Path((owner, name)): Path<(String, String)>,
1265 
    Json(body): Json<NewLabel>,
1266 
) -> Result<(StatusCode, Json<Label>), ApiError> {
1267 
    let c = caller(&app, &headers).await?;
1268 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
1269 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1270 
    if role < Role::Triage {
1271 
        return Err(forbidden("labels need triage access"));
1272 
    }
1273 
    let label = body.name.trim();
1274 
    if label.is_empty() || label.len() > 50 {
1275 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a label has a name of 1 to 50 characters".into()));
1276 
    }
1277 
    let colour = match body.colour.as_deref() {
1278 
        Some(c) if c.len() == 7 && c.starts_with('#') && c[1..].chars().all(|x| x.is_ascii_hexdigit()) => c.to_string(),
1279 
        Some(c) => return Err(ApiError(StatusCode::BAD_REQUEST, format!("colour {c:?} is not #rrggbb"))),
1280 
        None => "#5aa8ff".to_string(),
1281 
    };
1282 
    let l = db::issues::upsert_label(&app.db, row.id, label, &colour, body.description.trim()).await?;
1283 
    Ok((StatusCode::CREATED, Json(Label { name: l.name, colour: l.colour, description: l.description })))
1284 
}
1285
1286 
/// `DELETE /repos/{o}/{n}/labels/{label}` (triage).
1287 
async fn delete_label(
1288 
    State(app): State<Shared>,
1289 
    headers: HeaderMap,
1290 
    Path((owner, name, label)): Path<(String, String, String)>,
1291 
) -> Result<StatusCode, ApiError> {
1292 
    let c = caller(&app, &headers).await?;
1293 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
1294 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1295 
    if role < Role::Triage {
1296 
        return Err(forbidden("labels need triage access"));
1297 
    }
1298 
    let l = db::issues::label_by_name(&app.db, row.id, &label).await?.ok_or_else(|| not_found("no such label"))?;
1299 
    db::issues::delete_label(&app.db, l.id).await?;
1300 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 1301 
}
1302
b64e2537 Andy McCall ↶ 1303 
async fn labels(
1304 
    State(app): State<Shared>,
1305 
    headers: HeaderMap,
1306 
    Path((owner, name)): Path<(String, String)>,
1307 
) -> Result<Json<Vec<Label>>, ApiError> {
1308 
    let c = caller(&app, &headers).await?;
1309 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1310 
    Ok(Json(
1311 
        db::issues::labels(&app.db, row.id)
1312 
            .await?
1313 
            .into_iter()
1314 
            .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
1315 
            .collect(),
1316 
    ))
1317 
}
1318
1319 
async fn milestones(
1320 
    State(app): State<Shared>,
1321 
    headers: HeaderMap,
1322 
    Path((owner, name)): Path<(String, String)>,
1323 
) -> Result<Json<Vec<Milestone>>, ApiError> {
1324 
    let c = caller(&app, &headers).await?;
1325 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1326 
    let mut out = Vec::new();
1327 
    for m in db::issues::milestones(&app.db, row.id).await? {
1328 
        let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
1329 
        out.push(Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed });
d23464c0 Andy McCall ↶ 1330 
    }
b64e2537 Andy McCall ↶ 1331 
    Ok(Json(out))
1332 
}
1333
1334 
// --------------------------------------------------------- hooks, checks
1335
1336 
fn hook_of(h: &db::hooks::Hook) -> Hook {
1337 
    Hook { id: h.id, url: h.url.clone(), events: h.events.clone(), active: h.active, created_ms: h.created_ms }
1338 
}
1339
1340 
async fn hooks(
1341 
    State(app): State<Shared>,
1342 
    headers: HeaderMap,
1343 
    Path((owner, name)): Path<(String, String)>,
1344 
) -> Result<Json<Vec<Hook>>, ApiError> {
1345 
    let c = caller(&app, &headers).await?;
1346 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
1347 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1348 
    Ok(Json(db::hooks::hooks_for_repo(&app.db, row.id).await?.iter().map(hook_of).collect()))
d23464c0 Andy McCall ↶ 1349 
}
1350
b64e2537 Andy McCall ↶ 1351 
async fn create_hook(
1352 
    State(app): State<Shared>,
1353 
    headers: HeaderMap,
1354 
    Path((owner, name)): Path<(String, String)>,
1355 
    Json(body): Json<NewHook>,
1356 
) -> Result<(StatusCode, Json<Hook>), ApiError> {
1357 
    let c = caller(&app, &headers).await?;
1358 
    let me = c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?.clone();
1359 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1360 
    if !(body.url.starts_with("http://") || body.url.starts_with("https://")) {
1361 
        return Err(ApiError(StatusCode::BAD_REQUEST, "the URL must be http or https".into()));
1362 
    }
1363 
    let h = db::hooks::create_hook(&app.db, Some(row.id), None, &body.url, &body.secret, &body.events).await?;
1364 
    db::accounts::audit(&app.db, Some(&me), "hook.created", &row.slug(), &body.url).await.ok();
1365 
    Ok((StatusCode::CREATED, Json(hook_of(&h))))
d23464c0 Andy McCall ↶ 1366 
}
1367
b64e2537 Andy McCall ↶ 1368 
async fn delete_hook(
1369 
    State(app): State<Shared>,
1370 
    headers: HeaderMap,
1371 
    Path((owner, name, id)): Path<(String, String, i64)>,
1372 
) -> Result<StatusCode, ApiError> {
1373 
    let c = caller(&app, &headers).await?;
1374 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
1375 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1376 
    if db::hooks::hook(&app.db, id).await?.is_some_and(|h| h.repo_id == Some(row.id)) {
1377 
        db::hooks::delete_hook(&app.db, id).await?;
1378 
    }
1379 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 1380 
}
1381
b64e2537 Andy McCall ↶ 1382 
pub fn check_of(c: &db::hooks::Check) -> Check {
1383 
    Check {
1384 
        state: c.state.clone(),
1385 
        name: c.name.clone(),
1386 
        status: CheckStatus::parse(&c.status).unwrap_or(CheckStatus::Queued),
1387 
        summary: c.summary.clone(),
1388 
        url: c.url.clone(),
1389 
        reporter: c.reporter.clone(),
1390 
        seal: if c.seal.is_empty() { None } else { Some(c.seal.clone()) },
1391 
        started_ms: c.started_ms,
1392 
        finished_ms: c.finished_ms,
1393 
    }
961c10be Andy McCall ↶ 1394 
}
1395
1396 
/// `GET /repos/{o}/{n}/checks/required`.
1397 
async fn required_checks(
1398 
    State(app): State<Shared>,
1399 
    headers: HeaderMap,
1400 
    Path((owner, name)): Path<(String, String)>,
1401 
) -> Result<Json<RequiredChecks>, ApiError> {
1402 
    let c = caller(&app, &headers).await?;
1403 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1404 
    Ok(Json(RequiredChecks { names: db::hooks::required_checks(&app.db, row.id).await? }))
1405 
}
1406
1407 
/// `PUT /repos/{o}/{n}/checks/required` (repository admin): the whole list.
1408 
async fn set_required_checks(
1409 
    State(app): State<Shared>,
1410 
    headers: HeaderMap,
1411 
    Path((owner, name)): Path<(String, String)>,
1412 
    Json(body): Json<RequiredChecks>,
1413 
) -> Result<Json<RequiredChecks>, ApiError> {
1414 
    let c = caller(&app, &headers).await?;
1415 
    c.require("repo:admin")?;
1416 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1417 
    let mut names: Vec<String> = body.names.iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()).collect();
1418 
    names.sort();
1419 
    names.dedup();
1420 
    if names.len() > 32 || names.iter().any(|n| n.len() > 100 || n.contains(',')) {
1421 
        return Err(ApiError(StatusCode::BAD_REQUEST, "at most 32 check names, each under 100 characters and without commas".into()));
1422 
    }
1423 
    db::hooks::set_required_checks(&app.db, row.id, &names).await?;
1424 
    db::accounts::audit(&app.db, c.account.as_ref(), "repo.required_checks", &format!("{owner}/{name}"), &names.join(", ")).await.ok();
1425 
    Ok(Json(RequiredChecks { names }))
d23464c0 Andy McCall ↶ 1426 
}
1427
b64e2537 Andy McCall ↶ 1428 
/// `POST /repos/{o}/{n}/checks`: any `checks:write` (or write) token may
1429 
/// report; the state hash names what was checked.
1430 
async fn post_check(
1431 
    State(app): State<Shared>,
1432 
    headers: HeaderMap,
1433 
    Path((owner, name)): Path<(String, String)>,
1434 
    Json(body): Json<NewCheck>,
1435 
) -> Result<(StatusCode, Json<Check>), ApiError> {
1436 
    let c = caller(&app, &headers).await?;
1437 
    let me = c.require("checks:write").or_else(|_| c.require("repo:write"))?.clone();
1438 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1439 
    if body.state.len() != 64 || !body.state.chars().all(|ch| ch.is_ascii_hexdigit()) {
1440 
        return Err(ApiError(StatusCode::BAD_REQUEST, "state is a 64-character hex state hash".into()));
1441 
    }
1442 
    if body.name.trim().is_empty() || body.name.len() > 100 {
1443 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a check has a short name".into()));
1444 
    }
1445 
    let ch = db::hooks::upsert_check(
1446 
        &app.db,
1447 
        row.id,
1448 
        &body.state,
1449 
        body.name.trim(),
1450 
        body.status.as_str(),
1451 
        &body.summary,
1452 
        &body.url,
1453 
        Some((me.id, &me.username)),
1454 
        body.seal.as_deref().unwrap_or(""),
1455 
    )
1456 
    .await?;
1457 
    let api = check_of(&ch);
1458 
    app.events.proposal(row.id, ProposalEvent { number: 0, kind: "check".into(), check: Some(api.clone()) });
1459 
    crate::hooks::emit(&app, &row, "check", &me.username, serde_json::json!({ "check": api })).await;
1460 
    Ok((StatusCode::CREATED, Json(api)))
d23464c0 Andy McCall ↶ 1461 
}
1462
b64e2537 Andy McCall ↶ 1463 
async fn checks_for_state(
1464 
    State(app): State<Shared>,
1465 
    headers: HeaderMap,
1466 
    Path((owner, name, state)): Path<(String, String, String)>,
1467 
) -> Result<Json<Vec<Check>>, ApiError> {
1468 
    let c = caller(&app, &headers).await?;
1469 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1470 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &state).await?.iter().map(check_of).collect()))
d23464c0 Andy McCall ↶ 1471 
}