OXYGENHUB
◆ image-check oxygenhub / crates / hub / src / api / mod.rs
103.0 KiB · Rust · last changed Placement ranks runners and says why a job ran where it did 24 days 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
df71c789 Andy McCall ↶ 18 
pub mod device;
92a797b2 Andy McCall ↶ 19 
mod images;
ef20fdc1 Andy McCall ↶ 20 
mod projects;
617c2840 Andy McCall ↶ 21 
mod reports;
ef20fdc1 Andy McCall ↶ 22
90326c96 Andy McCall ↶ 23 
/// Any other path under `/api/v1`: a problem document, not the site's page.
e9bfea8e Andy McCall ↶ 24 
/// `GET /api/v1/version`: the hub's version and build, and the Oxygen and
25 
/// OxygenFlow library versions it is built on.
26 
async fn version() -> Json<serde_json::Value> {
27 
    Json(crate::web::home::versions())
28 
}
29
90326c96 Andy McCall ↶ 30 
async fn no_route() -> ApiError {
31 
    ApiError(StatusCode::NOT_FOUND, "no such API route".into())
32 
}
33
17a3a84b Andy McCall ↶ 34 
/// A known route asked with a method it does not take: a problem body
35 
/// rather than axum's empty 405 (oxygenhub#115).
36 
async fn wrong_method(method: axum::http::Method, uri: axum::http::Uri) -> ApiError {
37 
    ApiError(StatusCode::METHOD_NOT_ALLOWED, format!("{} is an API route, but not for {method}", uri.path()))
38 
}
39
5533e91a Andy McCall ↶ 40 
/// The API, with release assets up to `asset_limit` bytes (the web form's
41 
/// limit too; axum's default of 2 MiB refused ordinary builds).
42 
pub fn router(asset_limit: usize) -> Router<Shared> {
d23464c0 Andy McCall ↶ 43 
    Router::new()
90326c96 Andy McCall ↶ 44 
        .fallback(no_route)
42fa9554 Andy McCall ↶ 45 
        .route("/flow/claim", post(crate::flow::claim))
b6b7e4cf Andy McCall ↶ 46 
        .route("/flow/runners/register", post(crate::flow::register))
92a797b2 Andy McCall ↶ 47 
        .route("/flow/images/missing", post(images::missing))
48 
        .route("/flow/images/chunks/{hash}", axum::routing::put(images::put_chunk).get(images::get_chunk))
49 
        .route(
50 
            "/flow/images/{hash}",
51 
            axum::routing::put(images::put_manifest).get(images::get_manifest).layer(axum::extract::DefaultBodyLimit::max(64 << 20)),
52 
        )
42fa9554 Andy McCall ↶ 53 
        .route("/flow/jobs/{id}/log", post(crate::flow::log))
54 
        .route("/flow/jobs/{id}/finish", post(crate::flow::finish))
4d2e44d7 Andy McCall ↶ 55 
        .route("/flow/jobs/{id}/decline", post(crate::flow::decline))
a3c8288b Andy McCall ↶ 56 
        .route(
57 
            "/flow/jobs/{id}/artifacts/{name}",
58 
            post(crate::flow::artifact).layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
59 
        )
a36bab6b Andy McCall ↶ 60 
        .route(
61 
            "/flow/jobs/{id}/reports/{name}/files",
62 
            post(crate::flow::report_file).layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
63 
        )
ef20fdc1 Andy McCall ↶ 64 
        .route("/projects/{owner}", get(projects::list).post(projects::create))
65 
        .route("/projects/{owner}/{number}", get(projects::board).patch(projects::edit))
17a3a84b Andy McCall ↶ 66 
        .route("/projects/{owner}/{number}/cards", get(projects::cards).post(projects::add_card))
ef20fdc1 Andy McCall ↶ 67 
        .route("/projects/{owner}/{number}/cards/{id}", axum::routing::patch(projects::move_card).delete(projects::remove_card))
df71c789 Andy McCall ↶ 68 
        .route("/device/code", post(device::code))
69 
        .route("/device/token", post(device::token))
b66e70b7 Andy McCall ↶ 70 
        .route("/runners", get(runners))
71 
        .route("/runners/queue", get(runner_queue))
72 
        .route("/runners/{id}/jobs", get(runner_jobs))
b64e2537 Andy McCall ↶ 73 
        .route("/user", get(me))
60f11b71 Andy McCall ↶ 74 
        .route("/user/token", axum::routing::delete(revoke_own_token))
e9bfea8e Andy McCall ↶ 75 
        .route("/version", get(version))
42a0ba4b Andy McCall ↶ 76 
        .route("/notifications", get(notifications))
77 
        .route("/notifications/read", post(notifications_read_all))
78 
        .route("/notifications/{id}/read", post(notification_read))
b64e2537 Andy McCall ↶ 79 
        .route("/users/{name}", get(user))
80 
        .route("/orgs/{name}", get(org))
81 
        .route("/search", get(search))
82 
        .route("/repos", get(list_repos).post(create_repo))
d23464c0 Andy McCall ↶ 83 
        .route("/repos/{owner}/{name}", get(get_repo))
84 
        .route("/repos/{owner}/{name}/bookmarks", get(bookmarks))
85 
        .route("/repos/{owner}/{name}/tags", get(tags))
b64e2537 Andy McCall ↶ 86 
        .route("/repos/{owner}/{name}/history/{r}", get(history))
87 
        .route("/repos/{owner}/{name}/changes/{hash}", get(change))
88 
        .route("/repos/{owner}/{name}/tree/{r}", get(tree_root))
89 
        .route("/repos/{owner}/{name}/tree/{r}/{*path}", get(tree))
90 
        .route("/repos/{owner}/{name}/file/{r}/{*path}", get(file))
91 
        .route("/repos/{owner}/{name}/blame/{r}/{*path}", get(blame))
92 
        .route("/repos/{owner}/{name}/conflicts", get(conflicts))
93 
        .route("/repos/{owner}/{name}/trust", get(trust))
df940d75 Andy McCall ↶ 94 
        .route("/repos/{owner}/{name}/releases/trust/{*tag}", get(release_trust))
b64e2537 Andy McCall ↶ 95 
        .route("/repos/{owner}/{name}/pushes", get(pushes))
96 
        .route("/repos/{owner}/{name}/proposals", get(proposals).post(create_proposal))
739a763a Andy McCall ↶ 97 
        .route("/repos/{owner}/{name}/proposals/{number}", get(proposal).patch(edit_proposal))
1f1eb06a Andy McCall ↶ 98 
        .route("/repos/{owner}/{name}/proposals/{number}/land", post(land_proposal))
b64e2537 Andy McCall ↶ 99 
        .route("/repos/{owner}/{name}/proposals/{number}/comments", get(proposal_comments).post(proposal_comment))
100 
        .route("/repos/{owner}/{name}/proposals/{number}/reviews", get(proposal_reviews).post(proposal_review))
cc1cd197 Andy McCall ↶ 101 
        .route("/repos/{owner}/{name}/proposals/{number}/reviewers", post(request_reviewers))
7d2eb590 Andy McCall ↶ 102 
        .route("/repos/{owner}/{name}/proposals/{number}/review-requests", post(request_assistant))
cc1cd197 Andy McCall ↶ 103 
        .route("/repos/{owner}/{name}/proposals/{number}/reviewers/{username}", axum::routing::delete(withdraw_reviewer))
b64e2537 Andy McCall ↶ 104 
        .route("/repos/{owner}/{name}/proposals/{number}/checks", get(proposal_checks))
3f02e5ea Andy McCall ↶ 105 
        .route("/repos/{owner}/{name}/proposals/{number}/files", get(proposal_files))
106 
        .route("/repos/{owner}/{name}/proposals/{number}/content/{side}/{*path}", get(proposal_content))
b64e2537 Andy McCall ↶ 107 
        .route("/repos/{owner}/{name}/issues", get(issues).post(create_issue))
76f262e1 Andy McCall ↶ 108 
        .route("/repos/{owner}/{name}/issues/{number}", get(issue).post(issue_state).patch(issue_edit))
b64e2537 Andy McCall ↶ 109 
        .route("/repos/{owner}/{name}/issues/{number}/comments", get(issue_comments).post(issue_comment))
76f262e1 Andy McCall ↶ 110 
        .route("/repos/{owner}/{name}/labels", get(labels).post(create_label))
111 
        .route("/repos/{owner}/{name}/labels/{label}", axum::routing::delete(delete_label))
5ea4872f Andy McCall ↶ 112 
        .route("/repos/{owner}/{name}/milestones", get(milestones).post(create_milestone))
40dd3f86 Andy McCall ↶ 113 
        .route(
114 
            "/repos/{owner}/{name}/coverage",
115 
            get(reports::coverage_list)
116 
                .post(reports::coverage_upload)
117 
                .layer(axum::extract::DefaultBodyLimit::max(crate::coverage::MAX_REPORT + (1 << 20))),
118 
        )
617c2840 Andy McCall ↶ 119 
        .route("/repos/{owner}/{name}/coverage/{id}", get(reports::coverage_one))
120 
        .route("/repos/{owner}/{name}/tests", get(reports::tests_list))
121 
        .route("/repos/{owner}/{name}/tests/{id}", get(reports::tests_one))
5ea4872f Andy McCall ↶ 122 
        .route("/repos/{owner}/{name}/milestones/{title}", axum::routing::patch(edit_milestone))
b64e2537 Andy McCall ↶ 123 
        .route("/repos/{owner}/{name}/hooks", get(hooks).post(create_hook))
62ceb2ee Andy McCall ↶ 124 
        .route("/repos/{owner}/{name}/assistants", get(repo_assistants).post(repo_assistant_put))
125 
        .route("/repos/{owner}/{name}/assistants/prompt", get(repo_prompt).put(repo_prompt_put))
126 
        .route("/repos/{owner}/{name}/assistants/{assistant}", axum::routing::delete(repo_assistant_delete))
127 
        .route("/orgs/{org}/assistants", get(org_assistants).post(org_assistant_put))
128 
        .route("/orgs/{org}/assistants/prompt", get(org_prompt).put(org_prompt_put))
129 
        .route("/orgs/{org}/assistants/{assistant}", axum::routing::delete(org_assistant_delete))
130 
        .route("/admin/assistants", get(site_assistants).post(site_assistant_put))
131 
        .route("/admin/assistants/prompt", get(site_prompt).put(site_prompt_put))
132 
        .route("/admin/assistants/{assistant}", axum::routing::delete(site_assistant_delete))
b64e2537 Andy McCall ↶ 133 
        .route("/repos/{owner}/{name}/hooks/{id}/delete", post(delete_hook))
134 
        .route("/repos/{owner}/{name}/checks", post(post_check))
90326c96 Andy McCall ↶ 135 
        .route("/repos/{owner}/{name}/flow/runs", get(flow_runs).post(start_flow_run))
136 
        .route("/repos/{owner}/{name}/flow/runs/{number}", get(flow_run))
137 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/log", get(flow_job_log))
1edac4b6 Andy McCall ↶ 138 
        .route("/repos/{owner}/{name}/flow/runs/{number}/rerun", post(rerun_flow_run))
745d225d Andy McCall ↶ 139 
        .route("/repos/{owner}/{name}/flow/runs/{number}/cancel", post(cancel_flow_run))
961c10be Andy McCall ↶ 140 
        .route("/repos/{owner}/{name}/checks/required", get(required_checks).put(set_required_checks))
b64e2537 Andy McCall ↶ 141 
        .route("/repos/{owner}/{name}/checks/{state}", get(checks_for_state))
3f4b0ea6 Andy McCall ↶ 142 
        .route("/repos/{owner}/{name}/releases", get(releases).post(create_release))
ced6d3af Andy McCall ↶ 143 
        .route("/repos/{owner}/{name}/releases/{tag}", axum::routing::patch(edit_release))
5533e91a Andy McCall ↶ 144 
        .route(
145 
            "/repos/{owner}/{name}/releases/{tag}/assets",
146 
            post(upload_asset).layer(axum::extract::DefaultBodyLimit::max(asset_limit + (1 << 20))),
147 
        )
17a3a84b Andy McCall ↶ 148 
        // Last: it applies to the routes registered before it.
149 
        .method_not_allowed_fallback(wrong_method)
3f4b0ea6 Andy McCall ↶ 150 
}
151
152 
async fn releases(
153 
    State(app): State<Shared>,
154 
    headers: HeaderMap,
155 
    Path((owner, name)): Path<(String, String)>,
156 
) -> Result<Json<Vec<Release>>, ApiError> {
157 
    let c = caller(&app, &headers).await?;
158 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
159 
    Ok(Json(crate::web::releases::api_views(&app, &repo, &row).await?))
160 
}
161
162 
async fn create_release(
163 
    State(app): State<Shared>,
164 
    headers: HeaderMap,
165 
    Path((owner, name)): Path<(String, String)>,
166 
    Json(body): Json<NewRelease>,
167 
) -> Result<(StatusCode, Json<Release>), ApiError> {
168 
    let c = caller(&app, &headers).await?;
169 
    let me = c.require("repo:write")?.clone();
170 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
171 
    crate::web::releases::create_release(&app, &repo, &row, &me, &body.tag, &body.title, body.notes, body.prerelease)
172 
        .await
173 
        .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
174 
    let r = crate::web::releases::api_views(&app, &repo, &row)
175 
        .await?
176 
        .into_iter()
177 
        .find(|r| r.tag == body.tag)
178 
        .ok_or_else(|| not_found("no such release"))?;
179 
    Ok((StatusCode::CREATED, Json(r)))
180 
}
181
ced6d3af Andy McCall ↶ 182 
/// `PATCH …/releases/{tag}` (oxygenhub#72): change a release's title,
183 
/// notes or prerelease flag, as the release page's Edit does.
184 
async fn edit_release(
185 
    State(app): State<Shared>,
186 
    headers: HeaderMap,
187 
    Path((owner, name, tag)): Path<(String, String, String)>,
188 
    Json(body): Json<ReleaseEdit>,
189 
) -> Result<Json<Release>, ApiError> {
190 
    let c = caller(&app, &headers).await?;
191 
    let me = c.require("repo:write")?.clone();
192 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
193 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
194 
    let title = body.title.as_deref().map(str::trim).filter(|t| !t.is_empty()).unwrap_or(&r.title);
195 
    let notes = body.notes.as_deref().map(str::trim).unwrap_or(&r.notes);
196 
    db::releases::edit(&app.db, r.id, title, notes, body.prerelease.unwrap_or(r.prerelease)).await?;
197 
    db::accounts::audit(&app.db, Some(&me), "release.edited", &format!("{owner}/{name}@{tag}"), "").await.ok();
198 
    let r = crate::web::releases::api_views(&app, &repo, &row)
199 
        .await?
200 
        .into_iter()
201 
        .find(|r| r.tag == tag)
202 
        .ok_or_else(|| not_found("no such release"))?;
203 
    Ok(Json(r))
204 
}
205
3f4b0ea6 Andy McCall ↶ 206 
#[derive(Deserialize)]
207 
struct AssetQuery {
208 
    name: String,
de505df5 Andy McCall ↶ 209 
}
210
3f4b0ea6 Andy McCall ↶ 211 
/// `POST …/releases/{tag}/assets?name=file.tar.gz` with the file as the body.
212 
async fn upload_asset(
213 
    State(app): State<Shared>,
214 
    headers: HeaderMap,
215 
    Path((owner, name, tag)): Path<(String, String, String)>,
216 
    Query(q): Query<AssetQuery>,
217 
    body: axum::body::Bytes,
218 
) -> Result<(StatusCode, Json<Release>), ApiError> {
219 
    let c = caller(&app, &headers).await?;
220 
    c.require("repo:write")?;
221 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
222 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
223 
    let ct = headers.get(axum::http::header::CONTENT_TYPE).and_then(|v| v.to_str().ok()).unwrap_or("application/octet-stream").to_string();
224 
    crate::web::releases::store_asset(&app, r.id, &q.name, &ct, &body).await.map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
225 
    let r = crate::web::releases::api_views(&app, &repo, &row)
226 
        .await?
227 
        .into_iter()
228 
        .find(|r| r.tag == tag)
229 
        .ok_or_else(|| not_found("no such release"))?;
230 
    Ok((StatusCode::CREATED, Json(r)))
231 
}
232
42fa9554 Andy McCall ↶ 233 
pub struct ApiError(pub StatusCode, pub String);
b64e2537 Andy McCall ↶ 234
235 
impl IntoResponse for ApiError {
236 
    fn into_response(self) -> Response {
237 
        let body = Problem { status: self.0.as_u16(), title: self.0.canonical_reason().unwrap_or("error").into(), detail: self.1 };
238 
        (self.0, [("content-type", "application/problem+json")], Json(body)).into_response()
de505df5 Andy McCall ↶ 239 
    }
b64e2537 Andy McCall ↶ 240 
}
241
242 
impl From<RepoError> for ApiError {
243 
    fn from(e: RepoError) -> ApiError {
244 
        match e {
245 
            RepoError::NotFound => not_found("no such repository"),
246 
            RepoError::Oxy(oxy_core::repo::RepoError::Msg(m)) => ApiError(StatusCode::NOT_FOUND, m),
247 
            other => ApiError(StatusCode::INTERNAL_SERVER_ERROR, other.to_string()),
248 
        }
249 
    }
250 
}
251
252 
impl From<sqlx::Error> for ApiError {
253 
    fn from(e: sqlx::Error) -> ApiError {
254 
        ApiError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
255 
    }
256 
}
257
ef20fdc1 Andy McCall ↶ 258 
pub(crate) fn not_found(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 259 
    ApiError(StatusCode::NOT_FOUND, what.into())
260 
}
261
ef20fdc1 Andy McCall ↶ 262 
pub(crate) fn forbidden(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 263 
    ApiError(StatusCode::FORBIDDEN, what.into())
264 
}
265
60f11b71 Andy McCall ↶ 266 
/// The address a request came from: the client's, as the proxy reports
267 
/// it when the hub is behind one (`server.behind_proxy`), else the peer's.
268 
/// Only an address's characters are kept, so it is safe to show.
269 
pub fn client_addr(app: &Shared, headers: &HeaderMap, extensions: &axum::http::Extensions) -> String {
270 
    let from_proxy = || {
271 
        ["cf-connecting-ip", "x-forwarded-for", "x-real-ip"]
272 
            .iter()
273 
            .find_map(|h| headers.get(*h).and_then(|v| v.to_str().ok()).and_then(|v| v.split(',').next()).map(|v| v.trim().to_string()))
274 
    };
275 
    let addr = if app.config.server.behind_proxy {
276 
        from_proxy()
277 
    } else {
278 
        extensions.get::<axum::extract::ConnectInfo<std::net::SocketAddr>>().map(|c| c.0.ip().to_string())
279 
    };
280 
    addr.map(|a| a.chars().filter(|c| c.is_ascii_hexdigit() || matches!(c, '.' | ':')).take(45).collect()).unwrap_or_default()
281 
}
282
283 
/// `DELETE /api/v1/user/token`: revoke the token this request is made
284 
/// with, as `oxy auth logout` does.
285 
async fn revoke_own_token(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
286 
    let c = caller(&app, &headers).await?;
287 
    let (Some(account), Some(id)) = (c.account.as_ref(), c.token_id) else {
288 
        return Err(ApiError(StatusCode::UNAUTHORIZED, "revoking needs the personal access token to revoke".into()));
289 
    };
290 
    db::accounts::delete_token(&app.db, account.id, id).await?;
291 
    db::accounts::audit(&app.db, Some(account), "token.revoke", &c.token, "").await.ok();
292 
    Ok(StatusCode::NO_CONTENT)
293 
}
294
b64e2537 Andy McCall ↶ 295 
/// Who calls: the account behind a bearer token, with the token's scopes.
296 
pub struct Caller {
297 
    pub account: Option<Account>,
298 
    pub scopes: Vec<String>,
299 
    pub site: bool,
0b20f1ec Andy McCall ↶ 300 
    /// The token's name, for records of what a call did.
301 
    pub token: String,
60f11b71 Andy McCall ↶ 302 
    /// The personal access token's id, when one is used.
303 
    pub token_id: Option<i64>,
b64e2537 Andy McCall ↶ 304 
}
305
306 
impl Caller {
307 
    fn has(&self, scope: &str) -> bool {
308 
        self.site
309 
            || self.scopes.iter().any(|s| {
310 
                s == scope
311 
                    || (scope == "repo:read" && (s == "repo:write" || s == "repo:admin"))
312 
                    || (scope == "repo:write" && s == "repo:admin")
313 
            })
314 
    }
315
316 
    fn require(&self, scope: &str) -> Result<&Account, ApiError> {
317 
        if !self.has(scope) {
318 
            return Err(forbidden(&format!("this token lacks the {scope} scope")));
319 
        }
320 
        self.account.as_ref().ok_or_else(|| ApiError(StatusCode::UNAUTHORIZED, "a personal access token is required".into()))
321 
    }
322 
}
323
324 
pub async fn caller(app: &Shared, headers: &HeaderMap) -> Result<Caller, ApiError> {
0b20f1ec Andy McCall ↶ 325 
    let Some(t) = oxy_server::bearer_token(headers) else {
60f11b71 Andy McCall ↶ 326 
        return Ok(Caller { account: None, scopes: vec![], site: false, token: String::new(), token_id: None });
0b20f1ec Andy McCall ↶ 327 
    };
b64e2537 Andy McCall ↶ 328 
    if app.config.auth.push_tokens.iter().any(|x| auth::mac_equal(x, t)) {
329 
        let admin = db::accounts::accounts(&app.db).await?.into_iter().find(|a| a.is_admin);
0b20f1ec Andy McCall ↶ 330 
        return Ok(Caller {
331 
            account: admin,
332 
            scopes: vec!["repo:admin".into(), "user:read".into(), "checks:write".into()],
333 
            site: true,
334 
            token: "site token".into(),
60f11b71 Andy McCall ↶ 335 
            token_id: None,
0b20f1ec Andy McCall ↶ 336 
        });
b64e2537 Andy McCall ↶ 337 
    }
338 
    let token = db::accounts::token_by_hash(&app.db, &auth::token_hash(t)).await?;
de505df5 Andy McCall ↶ 339 
    match token {
b64e2537 Andy McCall ↶ 340 
        Some(tok) if !tok.expired(db::now_ms()) => {
6a178055 Andy McCall ↶ 341 
            let account = db::accounts::account_by_id(&app.db, tok.account_id).await?.filter(|a| !a.blocked());
b64e2537 Andy McCall ↶ 342 
            db::accounts::touch_token(&app.db, tok.id).await.ok();
60f11b71 Andy McCall ↶ 343 
            Ok(Caller {
344 
                account,
345 
                scopes: tok.scope_list().iter().map(|s| s.to_string()).collect(),
346 
                site: false,
347 
                token: tok.name.clone(),
348 
                token_id: Some(tok.id),
349 
            })
b64e2537 Andy McCall ↶ 350 
        }
de505df5 Andy McCall ↶ 351 
        _ => Err(ApiError(StatusCode::UNAUTHORIZED, "unknown or expired token".into())),
352 
    }
353 
}
354
b64e2537 Andy McCall ↶ 355 
fn repository(app: &Shared, r: &db::repos::RepoRow) -> Repository {
356 
    Repository {
357 
        owner: r.owner.clone(),
358 
        name: r.name.clone(),
359 
        description: r.description.clone(),
360 
        default_bookmark: r.default_bookmark.clone(),
361 
        visibility: r.visibility(),
362 
        created_ms: r.created_ms,
363 
        updated_ms: r.updated_ms,
364 
        clone_url: format!("{}/{}/{}", app.config.base_url(), r.owner, r.name),
365 
    }
366 
}
367
368 
/// A repository the caller may reach with `access`, else 404.
617c2840 Andy McCall ↶ 369 
pub(super) async fn reach(
de505df5 Andy McCall ↶ 370 
    app: &Shared,
b64e2537 Andy McCall ↶ 371 
    c: &Caller,
de505df5 Andy McCall ↶ 372 
    owner: &str,
373 
    name: &str,
b64e2537 Andy McCall ↶ 374 
    access: Access,
375 
) -> Result<(RepoName, db::repos::RepoRow, Role), ApiError> {
a0dd06b0 Andy McCall ↶ 376 
    // A wiki (`NAME.wiki`) has no row of its own, so no proposals, issues
377 
    // or runs (oxygenhub#128): say so to those who may read it, rather than
378 
    // that it does not exist.
379 
    if let Some(base) = name.strip_suffix(".wiki") {
380 
        if let Some(row) = db::repos::get(&app.db, owner, base).await? {
381 
            let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
382 
            if auth::roles::allows(role, Access::Read) {
383 
                return Err(not_found(&format!(
384 
                    "{owner}/{name} is the wiki of {owner}/{base}: it is cloned and pushed with oxy, and takes no proposals, \
385 
                     issues or runs; to publish a bookmark, merge it into main (oxy merge BOOKMARK on main) and push main"
386 
                )));
387 
            }
388 
        }
389 
    }
b64e2537 Andy McCall ↶ 390 
    let repo = RepoName::new(owner, name).ok_or_else(|| not_found("no such repository"))?;
391 
    let row = db::repos::get(&app.db, owner, name).await?.ok_or_else(|| not_found("no such repository"))?;
392 
    let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
393 
    if !auth::roles::allows(role, access) {
394 
        return Err(not_found("no such repository"));
395 
    }
396 
    Ok((repo, row, role.unwrap_or(Role::Read)))
397 
}
398
399 
fn summary(c: &view::ChangeView) -> ChangeSummary {
400 
    ChangeSummary {
401 
        hash: c.hash.clone(),
402 
        message: if c.body.is_empty() { c.title.clone() } else { format!("{}\n\n{}", c.title, c.body) },
403 
        author: Author {
404 
            name: c.author.name.clone(),
405 
            email: c.author.email.clone(),
406 
            key: c.author.key.clone(),
407 
            account: c.author.account.clone(),
760a7dd3 Andy McCall ↶ 408 
            note: Author::note_for(&c.author.key, &c.author.account),
b64e2537 Andy McCall ↶ 409 
        },
410 
        when_ms: c.when_ms,
411 
        deps: c.deps.clone(),
412 
        head: c.head,
8933faff Andy McCall ↶ 413 
        via: c.via.as_ref().map(|v| Via {
414 
            name: v.name.clone(),
415 
            key: v.key.clone(),
416 
            scope: v.scope.clone(),
417 
            expires_ms: v.expires_ms,
418 
            revoked: v.revoked,
419 
        }),
b64e2537 Andy McCall ↶ 420 
        signature: match &c.signature {
421 
            view::SigView::Unsigned => Signature::Unsigned,
422 
            view::SigView::Valid { key, sealed, revoked, .. } => Signature::Valid { key: key.clone(), sealed: *sealed, revoked: *revoked },
423 
            view::SigView::Invalid(why) => Signature::Invalid { reason: why.clone() },
424 
        },
425 
    }
426 
}
427
428 
// ---------------------------------------------------------------- accounts
429
430 
async fn me(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<User>, ApiError> {
431 
    let c = caller(&app, &headers).await?;
432 
    let a = c.require("user:read")?;
433 
    Ok(Json(user_of(&app, a).await?))
434 
}
435
42a0ba4b Andy McCall ↶ 436 
#[derive(Deserialize)]
437 
struct InboxQuery {
438 
    #[serde(default)]
439 
    limit: Option<i64>,
440 
}
441
442 
/// The caller's inbox; reading and clearing it needs `user:read`, since
443 
/// it touches nothing but the caller's own notifications.
444 
async fn notifications(
445 
    State(app): State<Shared>,
446 
    headers: HeaderMap,
447 
    Query(q): Query<InboxQuery>,
448 
) -> Result<Json<hub_api::Inbox>, ApiError> {
449 
    let c = caller(&app, &headers).await?;
450 
    let a = c.require("user:read")?;
451 
    let limit = q.limit.unwrap_or(50).clamp(1, 200);
452 
    let base = app.config.base_url().trim_end_matches('/').to_string();
453 
    let items = db::notify::inbox(&app.db, a.id, limit)
454 
        .await?
455 
        .into_iter()
456 
        .map(|n| hub_api::Notification {
457 
            id: n.id,
458 
            at_ms: n.at_ms,
459 
            kind: n.kind,
460 
            title: n.title,
461 
            url: if n.url.starts_with('/') { format!("{base}{}", n.url) } else { n.url },
462 
            actor: n.actor,
463 
            read: n.read,
464 
        })
465 
        .collect();
466 
    Ok(Json(hub_api::Inbox { unread: db::notify::unread(&app.db, a.id).await?, items }))
467 
}
468
469 
async fn notification_read(State(app): State<Shared>, headers: HeaderMap, Path(id): Path<i64>) -> Result<StatusCode, ApiError> {
470 
    let c = caller(&app, &headers).await?;
471 
    let a = c.require("user:read")?;
472 
    db::notify::mark_read(&app.db, a.id, Some(id)).await?;
473 
    Ok(StatusCode::NO_CONTENT)
474 
}
475
476 
async fn notifications_read_all(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
477 
    let c = caller(&app, &headers).await?;
478 
    let a = c.require("user:read")?;
479 
    db::notify::mark_read(&app.db, a.id, None).await?;
480 
    Ok(StatusCode::NO_CONTENT)
481 
}
482
b64e2537 Andy McCall ↶ 483 
async fn user_of(app: &Shared, a: &Account) -> Result<User, ApiError> {
484 
    let keys = db::accounts::identities_of(&app.db, a.id).await?.into_iter().map(|i| i.key).collect();
485 
    Ok(User { username: a.username.clone(), display_name: a.display_name.clone(), is_admin: a.is_admin, keys, created_ms: a.created_ms })
486 
}
487
488 
async fn user(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<User>, ApiError> {
489 
    let a = db::accounts::account_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such account"))?;
490 
    Ok(Json(user_of(&app, &a).await?))
491 
}
492
493 
async fn org(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<Organisation>, ApiError> {
494 
    let o = db::accounts::org_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such organisation"))?;
495 
    let members = db::accounts::org_members(&app.db, o.id).await?.into_iter().map(|(a, _)| a.username).collect();
496 
    Ok(Json(Organisation { name: o.name, display_name: o.display_name, description: o.description, members }))
497 
}
498
499 
#[derive(Deserialize)]
500 
struct SearchQuery {
501 
    q: String,
502 
}
503
504 
async fn search(
505 
    State(app): State<Shared>,
506 
    headers: HeaderMap,
507 
    Query(q): Query<SearchQuery>,
508 
) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
509 
    let c = caller(&app, &headers).await?;
510 
    let mut out = Vec::new();
511 
    for h in db::notify::search(&app.db, &q.q, None, 50).await? {
512 
        let Some(row) = db::repos::get_by_id(&app.db, h.repo_id).await? else { continue };
513 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
514 
        if !auth::roles::allows(role, Access::Read) {
515 
            continue;
516 
        }
517 
        out.push(
518 
            serde_json::json!({ "kind": h.kind, "repository": row.slug(), "number": h.number, "title": h.title, "snippet": h.snippet }),
519 
        );
520 
    }
521 
    Ok(Json(out))
522 
}
523
524 
// ------------------------------------------------------------ repositories
525
526 
async fn list_repos(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Repository>>, ApiError> {
527 
    let c = caller(&app, &headers).await?;
528 
    let mut out = Vec::new();
529 
    for r in db::repos::list(&app.db).await? {
530 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &r).await?;
531 
        if auth::roles::allows(role, Access::Read) {
532 
            out.push(repository(&app, &r));
533 
        }
de505df5 Andy McCall ↶ 534 
    }
b64e2537 Andy McCall ↶ 535 
    Ok(Json(out))
536 
}
537
538 
async fn create_repo(
539 
    State(app): State<Shared>,
540 
    headers: HeaderMap,
541 
    Json(body): Json<NewRepository>,
542 
) -> Result<(StatusCode, Json<Repository>), ApiError> {
543 
    let c = caller(&app, &headers).await?;
544 
    let me = c.require("repo:admin")?;
545 
    let name = RepoName::new(&body.owner, &body.name).ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "invalid owner or name".into()))?;
66fd9d6b Andy McCall ↶ 546 
    if name.name.ends_with(crate::wiki::SUFFIX) {
547 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a name cannot end in .wiki: that is the address of a repository's wiki".into()));
548 
    }
b64e2537 Andy McCall ↶ 549 
    if !auth::roles::may_create_under(&app.db, me, &name.owner).await? {
550 
        return Err(forbidden("you cannot create repositories under that owner"));
551 
    }
552 
    if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() || app.repos.exists(&name) {
553 
        return Err(ApiError(StatusCode::CONFLICT, "that repository exists".into()));
554 
    }
555 
    app.repos.create(&name, None)?;
556 
    let row = db::repos::create(&app.db, &name.owner, &name.name, &body.description, body.visibility).await?;
557 
    db::accounts::audit(&app.db, Some(me), "repo.created", &name.to_string(), "api").await.ok();
558 
    Ok((StatusCode::CREATED, Json(repository(&app, &row))))
559 
}
560
561 
async fn get_repo(
562 
    State(app): State<Shared>,
563 
    headers: HeaderMap,
564 
    Path((owner, name)): Path<(String, String)>,
565 
) -> Result<Json<Repository>, ApiError> {
566 
    let c = caller(&app, &headers).await?;
567 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
568 
    Ok(Json(repository(&app, &row)))
569 
}
570
571 
async fn bookmarks(
572 
    State(app): State<Shared>,
573 
    headers: HeaderMap,
574 
    Path((owner, name)): Path<(String, String)>,
575 
) -> Result<Json<Vec<Bookmark>>, ApiError> {
576 
    let c = caller(&app, &headers).await?;
577 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
578 
    let default = row.default_bookmark.clone();
579 
    let list = app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await?;
580 
    Ok(Json(list.into_iter().map(|b| Bookmark { name: b.name, heads: b.heads, changes: b.changes, default: b.default }).collect()))
581 
}
582
583 
async fn tags(
584 
    State(app): State<Shared>,
585 
    headers: HeaderMap,
586 
    Path((owner, name)): Path<(String, String)>,
587 
) -> Result<Json<Vec<Tag>>, ApiError> {
588 
    let c = caller(&app, &headers).await?;
589 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
590 
    let list = app.repos.read(&repo, |r, _| view::tags(r)).await?;
591 
    Ok(Json(list.into_iter().map(|t| Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer }).collect()))
592 
}
593
594 
#[derive(Deserialize)]
595 
struct HistoryQuery {
596 
    path: Option<String>,
597 
    offset: Option<usize>,
598 
    limit: Option<usize>,
f28389bd Andy McCall ↶ 599 
    /// A revset (Oxygen's docs/revset_query_language.md) in place of the
600 
    /// reference's whole history; the reference still gives the labels.
601 
    r: Option<String>,
b64e2537 Andy McCall ↶ 602 
}
603
604 
async fn history(
605 
    State(app): State<Shared>,
606 
    headers: HeaderMap,
607 
    Path((owner, name, r)): Path<(String, String, String)>,
608 
    Query(q): Query<HistoryQuery>,
609 
) -> Result<Json<History>, ApiError> {
610 
    let c = caller(&app, &headers).await?;
611 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
612 
    let (offset, limit) = (q.offset.unwrap_or(0), q.limit.unwrap_or(50).min(500));
f28389bd Andy McCall ↶ 613 
    let revset = q.r.clone().filter(|s| !s.trim().is_empty());
614 
    let by_revset = revset.is_some();
b64e2537 Andy McCall ↶ 615 
    let h = app
616 
        .repos
617 
        .read(&repo, move |repo, cache| {
618 
            let target = view::resolve(repo, cache, &r)?;
f28389bd Andy McCall ↶ 619 
            match &revset {
620 
                Some(rs) => view::history_revset(repo, cache, target, rs, offset, limit),
621 
                None => view::history(repo, cache, target, q.path.as_deref(), offset, limit),
622 
            }
b64e2537 Andy McCall ↶ 623 
        })
f28389bd Andy McCall ↶ 624 
        .await
625 
        .map_err(|e| {
626 
            // A revset that does not parse, names nothing, or goes past the
627 
            // budget is the caller's to fix.
628 
            if by_revset {
629 
                ApiError(StatusCode::BAD_REQUEST, e.to_string())
630 
            } else {
631 
                e.into()
632 
            }
633 
        })?;
b64e2537 Andy McCall ↶ 634 
    let mut entries = h.entries;
635 
    crate::web::attribute(&app, &mut entries.iter_mut().collect::<Vec<_>>()).await;
636 
    Ok(Json(History {
637 
        reference: h.target.label,
638 
        heads: h.target.heads.iter().map(|x| x.to_hex()).collect(),
639 
        total: h.total,
640 
        offset: h.offset,
641 
        changes: entries.iter().map(summary).collect(),
642 
    }))
643 
}
644
645 
async fn change(
646 
    State(app): State<Shared>,
647 
    headers: HeaderMap,
648 
    Path((owner, name, hash)): Path<(String, String, String)>,
649 
) -> Result<Json<ChangeDetail>, ApiError> {
650 
    let c = caller(&app, &headers).await?;
651 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
652 
    let d = app
653 
        .repos
654 
        .read(&repo, move |repo, cache| {
655 
            let h = view::resolve_change(repo, cache, &hash)?;
656 
            view::change(repo, cache, &h)
657 
        })
658 
        .await?;
659 
    let mut v = d.view;
660 
    crate::web::attribute(&app, &mut [&mut v]).await;
661 
    let files = crate::web::history::render_files(&d.files, &d.bases)
662 
        .into_iter()
663 
        .map(|f| FileChange { path: f.path, kind: f.kind, from: f.from, added: f.added, removed: f.removed })
664 
        .collect();
665 
    Ok(Json(ChangeDetail {
666 
        body: v.body.clone(),
667 
        change: summary(&v),
668 
        dependents: d.dependents.iter().map(|x| x.hash.clone()).collect(),
669 
        in_bookmarks: d.in_bookmarks,
670 
        in_tags: d.in_tags,
671 
        files,
672 
    }))
673 
}
674
675 
fn entry(e: &view::Entry) -> TreeEntry {
676 
    TreeEntry {
677 
        name: e.name.clone(),
678 
        path: e.path.clone(),
679 
        kind: match e.kind {
680 
            view::EntryKind::Dir => "dir",
681 
            view::EntryKind::File => "file",
682 
            view::EntryKind::Symlink => "symlink",
683 
            view::EntryKind::Subrepo => "subrepo",
684 
        }
685 
        .into(),
686 
        exec: e.exec,
687 
        size: e.size,
688 
        conflicted: e.conflicted,
689 
    }
690 
}
691
692 
async fn tree_root(
693 
    State(app): State<Shared>,
694 
    headers: HeaderMap,
695 
    Path((owner, name, r)): Path<(String, String, String)>,
696 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
697 
    tree(State(app), headers, Path((owner, name, r, String::new()))).await
698 
}
699
700 
async fn tree(
701 
    State(app): State<Shared>,
702 
    headers: HeaderMap,
703 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
704 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
705 
    let c = caller(&app, &headers).await?;
706 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
707 
    let t = app
708 
        .repos
709 
        .read(&repo, move |repo, cache| {
710 
            let target = view::resolve(repo, cache, &r)?;
711 
            view::tree(repo, cache, target, &path)
712 
        })
713 
        .await?;
714 
    Ok(Json(t.entries.iter().map(entry).collect()))
715 
}
716
717 
async fn file(
718 
    State(app): State<Shared>,
719 
    headers: HeaderMap,
720 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
721 
) -> Result<Response, ApiError> {
722 
    let c = caller(&app, &headers).await?;
723 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
724 
    let limit = app.config.limits.render_limit.0;
725 
    let f = app
726 
        .repos
727 
        .read(&repo, move |repo, cache| {
728 
            let target = view::resolve(repo, cache, &r)?;
729 
            view::file(repo, cache, target, &path, limit)
730 
        })
731 
        .await?;
732 
    Ok(crate::web::raw(f.bytes, &f.name, false))
733 
}
734
735 
async fn blame(
736 
    State(app): State<Shared>,
737 
    headers: HeaderMap,
738 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
739 
) -> Result<Json<Vec<BlameLine>>, ApiError> {
740 
    let c = caller(&app, &headers).await?;
741 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
742 
    let limit = app.config.limits.render_limit.0;
743 
    let b = app
744 
        .repos
745 
        .read(&repo, move |repo, cache| {
746 
            let target = view::resolve(repo, cache, &r)?;
747 
            view::blame(repo, cache, target, &path, limit)
748 
        })
749 
        .await?;
750 
    Ok(Json(
751 
        b.lines
752 
            .into_iter()
753 
            .map(|l| BlameLine {
754 
                line: l.line,
755 
                change: l.hash.to_hex(),
756 
                index: l.index,
757 
                author: l.author,
758 
                when_ms: l.when_ms,
759 
                text: String::from_utf8_lossy(&l.text).into_owned(),
760 
            })
761 
            .collect(),
762 
    ))
763 
}
764
765 
async fn conflicts(
766 
    State(app): State<Shared>,
767 
    headers: HeaderMap,
768 
    Path((owner, name)): Path<(String, String)>,
769 
) -> Result<Json<Vec<Conflict>>, ApiError> {
770 
    let c = caller(&app, &headers).await?;
771 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
772 
    let list = app.repos.read(&repo, view::conflicts).await?;
773 
    Ok(Json(
774 
        list.into_iter()
775 
            .map(|c| Conflict {
776 
                bookmark: c.bookmark,
777 
                path: c.path,
778 
                kind: c.kind,
779 
                contributors: c.contributors.iter().map(|x| x.hash.clone()).collect(),
780 
            })
781 
            .collect(),
782 
    ))
df940d75 Andy McCall ↶ 783 
}
784
785 
/// `GET /repos/{o}/{n}/releases/trust/{tag}`: a release's trust report
786 
/// (hub spec §9.1), as the page's JSON export.
787 
async fn release_trust(
788 
    State(app): State<Shared>,
789 
    headers: HeaderMap,
790 
    Path((owner, name, tag)): Path<(String, String, String)>,
791 
) -> Result<Json<crate::web::release_trust::ReleaseTrust>, ApiError> {
792 
    let c = caller(&app, &headers).await?;
793 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
794 
    match crate::web::release_trust::report(&app, &repo, &row, &tag).await.map_err(|m| ApiError(StatusCode::INTERNAL_SERVER_ERROR, m))? {
795 
        Some(t) => Ok(Json(t)),
796 
        None => Err(ApiError(StatusCode::NOT_FOUND, format!("no release {tag}"))),
797 
    }
b64e2537 Andy McCall ↶ 798 
}
799
800 
async fn trust(
801 
    State(app): State<Shared>,
802 
    headers: HeaderMap,
803 
    Path((owner, name)): Path<(String, String)>,
804 
) -> Result<Json<Trust>, ApiError> {
805 
    let c = caller(&app, &headers).await?;
806 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
807 
    let key = app.hub_key.key;
808 
    let t = app.repos.read(&repo, move |r, cache| view::trust(r, cache, &key)).await?;
809 
    Ok(Json(Trust {
810 
        policy: t.policy.map(|p| Policy {
811 
            serial: p.serial,
812 
            expires_ms: p.expires_ms,
813 
            roots: p.roots.iter().map(|k| k.key.clone()).collect(),
814 
            root_threshold: p.root_threshold,
815 
            rules: p
816 
                .rules
817 
                .iter()
818 
                .map(|r| Rule {
819 
                    pattern: r.pattern.clone(),
820 
                    keys: r.keys.iter().map(|k| k.key.clone()).collect(),
821 
                    threshold: r.threshold,
822 
                    require: r.require.clone(),
823 
                    allow_conflicts: r.allow_conflicts,
824 
                })
825 
                .collect(),
826 
        }),
827 
        signed: t.verification.signed,
828 
        sealed: t.verification.sealed,
829 
        unsigned: t.verification.unsigned,
830 
        invalid: t.verification.invalid.iter().map(|(h, _)| h.clone()).collect(),
831 
        hub_key: t.hub_key,
832 
    }))
833 
}
834
835 
async fn pushes(
836 
    State(app): State<Shared>,
837 
    headers: HeaderMap,
838 
    Path((owner, name)): Path<(String, String)>,
839 
) -> Result<Json<Vec<Push>>, ApiError> {
840 
    let c = caller(&app, &headers).await?;
841 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
842 
    let rows = db::repos::pushes(&app.db, row.id, 200).await?;
843 
    Ok(Json(
844 
        rows.into_iter()
845 
            .map(|p| Push {
846 
                at_ms: p.at_ms,
847 
                pusher: p.pusher,
848 
                reference: p.reference,
849 
                ok: p.ok,
850 
                reason: p.reason,
851 
                old_state: p.old_state,
852 
                new_state: p.new_state,
853 
                heads: p.heads,
854 
                changes: p.changes,
855 
            })
856 
            .collect(),
857 
    ))
de505df5 Andy McCall ↶ 858 
}
859
b64e2537 Andy McCall ↶ 860 
// --------------------------------------------------------------- proposals
861
0b20f1ec Andy McCall ↶ 862 
/// `GET /repos/{o}/{n}/proposals?state=open|draft|landed|closed|all`:
863 
/// open ones (drafts too) by default.
de505df5 Andy McCall ↶ 864 
async fn proposals(
865 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 866 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 867 
    Path((owner, name)): Path<(String, String)>,
0b20f1ec Andy McCall ↶ 868 
    Query(q): Query<IssuesQuery>,
b64e2537 Andy McCall ↶ 869 
) -> Result<Json<Vec<Proposal>>, ApiError> {
870 
    let c = caller(&app, &headers).await?;
871 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
0b20f1ec Andy McCall ↶ 872 
    let states: &[&str] = match q.state.as_deref().unwrap_or("open") {
873 
        "open" => &["open", "draft"],
874 
        "draft" => &["draft"],
875 
        "landed" => &["landed"],
876 
        "closed" => &["closed"],
877 
        "all" => &["open", "draft", "landed", "closed"],
878 
        other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state is open, draft, landed, closed or all, not {other:?}"))),
879 
    };
de505df5 Andy McCall ↶ 880 
    let mut out = Vec::new();
0b20f1ec Andy McCall ↶ 881 
    for p in db::proposals::list(&app.db, row.id, states).await? {
de505df5 Andy McCall ↶ 882 
        let loaded = crate::web::proposals::load(&app, &repo, p).await?;
883 
        let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
884 
        out.push(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await);
885 
    }
886 
    Ok(Json(out))
887 
}
888
889 
async fn proposal(
890 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 891 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 892 
    Path((owner, name, number)): Path<(String, String, i64)>,
b64e2537 Andy McCall ↶ 893 
) -> Result<Json<Proposal>, ApiError> {
894 
    let c = caller(&app, &headers).await?;
895 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
896 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
de505df5 Andy McCall ↶ 897 
    let source_url = match p.source_repo_id {
898 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
899 
        None => None,
900 
    };
901 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
902 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
903 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
1f1eb06a Andy McCall ↶ 904 
}
905
739a763a Andy McCall ↶ 906 
/// `PATCH /repos/{o}/{n}/proposals/{number}`: change the title or body,
907 
/// keeping what is not given; the author or a maintainer, as on the page
908 
/// (oxygenhub#76). The target is changed on the page, which re-projects.
909 
async fn edit_proposal(
910 
    State(app): State<Shared>,
911 
    headers: HeaderMap,
912 
    Path((owner, name, number)): Path<(String, String, i64)>,
913 
    Json(body): Json<hub_api::ProposalEdit>,
914 
) -> Result<Json<Proposal>, ApiError> {
915 
    let c = caller(&app, &headers).await?;
916 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
917 
    let (repo, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
918 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2291f8cc Andy McCall ↶ 919 
    let text = body.title.is_some() || body.body.is_some();
920 
    if text && Some(me.id) != p.author_id && role < Role::Maintain {
739a763a Andy McCall ↶ 921 
        return Err(ApiError(StatusCode::FORBIDDEN, "only the proposal's author or a maintainer can edit it".into()));
2291f8cc Andy McCall ↶ 922 
    }
923 
    if body.labels.is_some() && role < Role::Triage {
924 
        return Err(forbidden("setting labels needs triage access"));
925 
    }
926 
    // Every name is checked before anything changes.
927 
    let labels = resolve_triage(&app, row.id, body.labels.as_deref(), None, None).await?.labels;
928 
    if text {
929 
        let title = match body.title.as_deref().map(str::trim) {
930 
            Some("") => return Err(ApiError(StatusCode::BAD_REQUEST, "a proposal needs a title".into())),
931 
            Some(t) => t,
932 
            None => p.title.as_str(),
933 
        };
934 
        let text = body.body.as_deref().map(str::trim).unwrap_or(&p.body);
935 
        db::proposals::edit(&app.db, p.id, title, text, &p.target).await?;
936 
        db::proposals::add_event(&app.db, p.id, &me.username, "edited", "").await.ok();
739a763a Andy McCall ↶ 937 
    }
2291f8cc Andy McCall ↶ 938 
    if let Some(want) = labels {
939 
        let have = db::issues::proposal_labels(&app.db, p.id).await?;
940 
        for l in &have {
941 
            if !want.iter().any(|w| w.id == l.id) {
942 
                db::issues::set_proposal_label(&app.db, p.id, l.id, false).await?;
943 
            }
944 
        }
945 
        for w in &want {
946 
            if !have.iter().any(|l| l.id == w.id) {
947 
                db::issues::set_proposal_label(&app.db, p.id, w.id, true).await?;
948 
            }
949 
        }
950 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
951 
        db::proposals::add_event(&app.db, p.id, &me.username, "set labels", &names.join(", ")).await.ok();
952 
    }
739a763a Andy McCall ↶ 953 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
954 
    let source_url = match p.source_repo_id {
955 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
956 
        None => None,
957 
    };
958 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
959 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
960 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
961 
}
962
1f1eb06a Andy McCall ↶ 963 
/// `POST /repos/{o}/{n}/proposals/{number}/land` (repo:write): land it as
964 
/// the page's Land button does; `409` with the blockers when it cannot.
965 
async fn land_proposal(
966 
    State(app): State<Shared>,
967 
    headers: HeaderMap,
968 
    Path((owner, name, number)): Path<(String, String, i64)>,
969 
) -> Result<Json<Proposal>, ApiError> {
970 
    let c = caller(&app, &headers).await?;
971 
    let me = c.require("repo:write")?.clone();
972 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
0b20f1ec Andy McCall ↶ 973 
    let via = format!("api (token {})", c.token);
974 
    match crate::web::proposals::land_as(&app, &repo, &row, &me, number, &via).await {
1f1eb06a Andy McCall ↶ 975 
        Ok(_) => proposal(State(app), headers, Path((owner, name, number))).await,
976 
        Err(crate::web::proposals::Landing::NotFound) => Err(not_found("no such proposal")),
977 
        Err(crate::web::proposals::Landing::Refused(m)) => Err(ApiError(StatusCode::CONFLICT, m)),
978 
    }
d23464c0 Andy McCall ↶ 979 
}
980
3f02e5ea Andy McCall ↶ 981 
/// The files a proposal changes (hub spec §12.1).
982 
async fn proposal_files(
983 
    State(app): State<Shared>,
984 
    headers: HeaderMap,
985 
    Path((owner, name, number)): Path<(String, String, i64)>,
986 
) -> Result<Json<Vec<hub_api::ProposalFile>>, ApiError> {
987 
    let c = caller(&app, &headers).await?;
988 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
989 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
990 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
991 
    Ok(Json(
992 
        loaded
993 
            .files
994 
            .iter()
995 
            .map(|f| hub_api::ProposalFile {
996 
                path: f.path.clone(),
997 
                from: f.from.clone(),
998 
                kind: f.kind.clone(),
999 
                added: f.added,
1000 
                removed: f.removed,
1001 
            })
1002 
            .collect(),
1003 
    ))
1004 
}
1005
1006 
/// One file's bytes on a side of a proposal: `base` is the target's
1007 
/// state, `head` the projected state. 404 when the file does not exist
1008 
/// on that side.
1009 
async fn proposal_content(
1010 
    State(app): State<Shared>,
1011 
    headers: HeaderMap,
1012 
    Path((owner, name, number, side, path)): Path<(String, String, i64, String, String)>,
1013 
) -> Result<Response, ApiError> {
1014 
    let c = caller(&app, &headers).await?;
1015 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1016 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1017 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
1018 
    let heads = match side.as_str() {
1019 
        "base" => loaded.target_heads,
1020 
        "head" => loaded.heads,
1021 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "the side is base or head".into())),
1022 
    };
1023 
    let limit = app.config.limits.render_limit.0;
1024 
    let target = view::RefTarget { label: side, kind: view::RefKind::Change, heads };
1025 
    let f = app.repos.read(&repo, move |repo, cache| view::file(repo, cache, target, &path, limit)).await?;
1026 
    Ok(crate::web::raw(f.bytes, &f.name, false))
1027 
}
1028
b64e2537 Andy McCall ↶ 1029 
async fn create_proposal(
1030 
    State(app): State<Shared>,
1031 
    headers: HeaderMap,
1032 
    Path((owner, name)): Path<(String, String)>,
1033 
    Json(body): Json<NewProposal>,
1034 
) -> Result<(StatusCode, Json<Proposal>), ApiError> {
1035 
    let c = caller(&app, &headers).await?;
1036 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1037 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1038 
    let created =
1039 
        crate::web::proposals::open_proposal(&app, &repo, &row, &me, &body.title, &body.body, &body.target, &body.source, body.draft)
1040 
            .await
1041 
            .map_err(|e| ApiError(StatusCode::BAD_REQUEST, e))?;
1042 
    let loaded = crate::web::proposals::load(&app, &repo, created).await?;
1043 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1044 
    Ok((StatusCode::CREATED, Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)))
1045 
}
d23464c0 Andy McCall ↶ 1046
b64e2537 Andy McCall ↶ 1047 
fn comment_of(c: &db::proposals::CommentRow) -> Comment {
1048 
    Comment {
1049 
        id: c.id,
1050 
        author: c.author.clone(),
1051 
        body: c.body.clone(),
1052 
        created_ms: c.created_ms,
1053 
        path: if c.path.is_empty() { None } else { Some(c.path.clone()) },
1054 
        anchor: if c.anchor_change.is_empty() {
1055 
            None
1056 
        } else {
1057 
            Some(Atom { change: c.anchor_change.clone(), index: c.anchor_index as u32 })
1058 
        },
c0fac31d Andy McCall ↶ 1059 
        line: None,
b64e2537 Andy McCall ↶ 1060 
        resolved: c.resolved,
d23464c0 Andy McCall ↶ 1061 
    }
1062 
}
1063
b64e2537 Andy McCall ↶ 1064 
async fn proposal_comments(
1065 
    State(app): State<Shared>,
1066 
    headers: HeaderMap,
1067 
    Path((owner, name, number)): Path<(String, String, i64)>,
1068 
) -> Result<Json<Vec<Comment>>, ApiError> {
1069 
    let c = caller(&app, &headers).await?;
1070 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1071 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
c0fac31d Andy McCall ↶ 1072 
    let mut out: Vec<Comment> = db::proposals::comments(&app.db, p.id).await?.iter().map(comment_of).collect();
1073 
    // Place anchored comments on their line of the projected state.
1074 
    let paths: std::collections::BTreeSet<String> = out.iter().filter(|c| c.anchor.is_some()).filter_map(|c| c.path.clone()).collect();
1075 
    if !paths.is_empty() {
1076 
        let repo = RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?;
1077 
        let heads = crate::web::proposals::load(&app, &repo, p).await?.heads;
1078 
        let lines = app
1079 
            .repos
1080 
            .read(&repo, move |r, _| {
1081 
                let mut at = std::collections::HashMap::new();
1082 
                for path in paths {
1083 
                    // A file the projection removed has no lines to place a comment on.
1084 
                    for l in r.blame_in(&path, &heads).unwrap_or_default() {
1085 
                        at.insert((path.clone(), l.hash.to_hex(), l.index), l.line);
1086 
                    }
1087 
                }
1088 
                Ok(at)
1089 
            })
1090 
            .await?;
1091 
        for c in &mut out {
1092 
            if let (Some(path), Some(a)) = (&c.path, &c.anchor) {
1093 
                c.line = lines.get(&(path.clone(), a.change.clone(), a.index)).copied();
1094 
            }
1095 
        }
1096 
    }
1097 
    Ok(Json(out))
b64e2537 Andy McCall ↶ 1098 
}
1099
1100 
async fn proposal_comment(
1101 
    State(app): State<Shared>,
1102 
    headers: HeaderMap,
1103 
    Path((owner, name, number)): Path<(String, String, i64)>,
1104 
    Json(body): Json<NewComment>,
1105 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
1106 
    let c = caller(&app, &headers).await?;
1107 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1108 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1109 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1110 
    if body.body.trim().is_empty() {
1111 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
1112 
    }
3f4b0ea6 Andy McCall ↶ 1113 
    let (repo, _) = (RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?, ());
1114 
    let anchor = match (body.path.as_deref().map(|x| x.trim_matches('/')), body.line) {
1115 
        (Some(path), Some(line)) if !path.is_empty() => {
1116 
            let loaded = crate::web::proposals::load(&app, &repo, p.clone()).await?;
1117 
            let (heads, file) = (loaded.heads.clone(), path.to_string());
1118 
            let atom = app
1119 
                .repos
1120 
                .read(&repo, move |r, cache| {
1121 
                    let projected = cache.load(r, &heads)?;
1122 
                    Ok(crate::repos::proposals::atom_at(&projected, &file, line).map(|(h, i)| (h.to_hex(), i)))
1123 
                })
1124 
                .await?
1125 
                .ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, format!("{path}:{line} is not a line of the projected state")))?;
1126 
            Some((path.to_string(), atom))
1127 
        }
1128 
        _ => None,
1129 
    };
1130 
    let row_c = db::proposals::add_comment(
1131 
        &app.db,
1132 
        p.id,
1133 
        Some(me.id),
1134 
        &me.username,
1135 
        body.body.trim(),
1136 
        anchor.as_ref().map(|(path, _)| path.as_str()).unwrap_or(""),
1137 
        anchor.as_ref().map(|(_, (h, i))| (h.as_str(), *i as i64)),
1138 
    )
1139 
    .await?;
b64e2537 Andy McCall ↶ 1140 
    crate::notify::deliver(
1141 
        &app,
1142 
        crate::notify::Event {
1143 
            kind: "proposal.comment",
1144 
            title: format!("{owner}/{name}#{number}: {}", p.title),
1145 
            url: format!("/{owner}/{name}/proposal/{number}"),
1146 
            actor: &me,
1147 
            repo_id: row.id,
1148 
            thread: Some(("proposal", p.id)),
1149 
            mention_text: &body.body,
1150 
            direct: p.author_id.into_iter().collect(),
1151 
        },
1152 
    )
1153 
    .await;
1154 
    crate::hooks::emit(
1155 
        &app,
1156 
        &row,
1157 
        "comment.proposal",
1158 
        &me.username,
1159 
        serde_json::json!({ "number": number, "comment": comment_of(&row_c) }),
1160 
    )
1161 
    .await;
c0fac31d Andy McCall ↶ 1162 
    let mut created = comment_of(&row_c);
1163 
    created.line = created.anchor.as_ref().and(body.line);
1164 
    Ok((StatusCode::CREATED, Json(created)))
b64e2537 Andy McCall ↶ 1165 
}
1166
1167 
async fn proposal_reviews(
1168 
    State(app): State<Shared>,
1169 
    headers: HeaderMap,
1170 
    Path((owner, name, number)): Path<(String, String, i64)>,
1171 
) -> Result<Json<Vec<Review>>, ApiError> {
1172 
    let c = caller(&app, &headers).await?;
1173 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1174 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1175 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
1176 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1177 
    Ok(Json(
1178 
        v.reviews
1179 
            .into_iter()
1180 
            .map(|r| Review {
1181 
                id: r.row.id,
1182 
                author: r.row.author,
1183 
                verdict: r.row.verdict,
1184 
                body: r.row.body,
1185 
                sealed: r.sealed,
1186 
                created_ms: r.row.created_ms,
7d2eb590 Andy McCall ↶ 1187 
                via: r.row.via,
b64e2537 Andy McCall ↶ 1188 
            })
1189 
            .collect(),
1190 
    ))
1191 
}
1192
1193 
async fn proposal_review(
1194 
    State(app): State<Shared>,
1195 
    headers: HeaderMap,
1196 
    Path((owner, name, number)): Path<(String, String, i64)>,
1197 
    Json(body): Json<NewReview>,
1198 
) -> Result<(StatusCode, Json<Review>), ApiError> {
1199 
    let c = caller(&app, &headers).await?;
1200 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1201 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1202 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1203 
    if !matches!(body.verdict.as_str(), "comment" | "changes" | "approve") {
1204 
        return Err(ApiError(StatusCode::BAD_REQUEST, "verdict is comment, changes or approve".into()));
1205 
    }
1206 
    if body.verdict == "approve" && Some(me.id) == p.author_id {
1207 
        return Err(forbidden("you cannot approve your own proposal"));
1208 
    }
1209 
    let r = db::proposals::add_review(&app.db, p.id, me.id, &me.username, &body.verdict, body.body.trim()).await?;
1210 
    db::proposals::add_event(&app.db, p.id, &me.username, &format!("review.{}", body.verdict), "").await.ok();
cc1cd197 Andy McCall ↶ 1211 
    crate::web::proposals::reviewed(&app, &row, &p, &me, &body.verdict).await;
b64e2537 Andy McCall ↶ 1212 
    crate::hooks::emit(&app, &row, "review", &me.username, serde_json::json!({ "number": number, "verdict": body.verdict })).await;
1213 
    Ok((
1214 
        StatusCode::CREATED,
7d2eb590 Andy McCall ↶ 1215 
        Json(Review { id: r.id, author: r.author, verdict: r.verdict, body: r.body, sealed: false, created_ms: r.created_ms, via: r.via }),
b64e2537 Andy McCall ↶ 1216 
    ))
1217 
}
1218
cc1cd197 Andy McCall ↶ 1219 
/// `POST .../proposals/{number}/reviewers`: ask accounts to review (the
1220 
/// author, or a writer). Answers with everyone asked now.
1221 
async fn request_reviewers(
1222 
    State(app): State<Shared>,
1223 
    headers: HeaderMap,
1224 
    Path((owner, name, number)): Path<(String, String, i64)>,
1225 
    Json(body): Json<ReviewRequest>,
1226 
) -> Result<Json<Vec<String>>, ApiError> {
1227 
    let c = caller(&app, &headers).await?;
1228 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1229 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1230 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1231 
    if Some(me.id) != p.author_id && role < Role::Write {
1232 
        return Err(forbidden("only the author or a writer asks for reviews"));
1233 
    }
1234 
    if !p.is_open() {
1235 
        return Err(ApiError(StatusCode::CONFLICT, "the proposal is not open".into()));
1236 
    }
1237 
    crate::web::proposals::request_reviewers(&app, &row, &p, &me, &body.reviewers)
1238 
        .await
1239 
        .map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
1240 
    Ok(Json(db::proposals::review_requests(&app.db, p.id).await?))
1241 
}
1242
1243 
/// `DELETE .../proposals/{number}/reviewers/{username}`: withdraw a request.
1244 
async fn withdraw_reviewer(
1245 
    State(app): State<Shared>,
1246 
    headers: HeaderMap,
1247 
    Path((owner, name, number, username)): Path<(String, String, i64, String)>,
1248 
) -> Result<StatusCode, ApiError> {
1249 
    let c = caller(&app, &headers).await?;
1250 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1251 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1252 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1253 
    if Some(me.id) != p.author_id && role < Role::Write {
1254 
        return Err(forbidden("only the author or a writer withdraws review requests"));
1255 
    }
1256 
    let a = db::accounts::account_by_name(&app.db, &username).await?.ok_or_else(|| not_found("no such account"))?;
1257 
    if db::proposals::unrequest_review(&app.db, p.id, a.id).await? {
1258 
        db::proposals::add_event(&app.db, p.id, &me.username, "review request withdrawn", &a.username).await.ok();
1259 
    }
1260 
    Ok(StatusCode::NO_CONTENT)
1261 
}
1262
b64e2537 Andy McCall ↶ 1263 
async fn proposal_checks(
1264 
    State(app): State<Shared>,
1265 
    headers: HeaderMap,
1266 
    Path((owner, name, number)): Path<(String, String, i64)>,
1267 
) -> Result<Json<Vec<Check>>, ApiError> {
1268 
    let c = caller(&app, &headers).await?;
1269 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1270 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1271 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
1272 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await?.iter().map(check_of).collect()))
1273 
}
1274
1275 
// ------------------------------------------------------------------ issues
1276
1277 
async fn issue_of(app: &Shared, row: &db::repos::RepoRow, i: &db::issues::IssueRow) -> Result<Issue, ApiError> {
1278 
    let labels = db::issues::issue_labels(&app.db, i.id)
1279 
        .await?
1280 
        .into_iter()
1281 
        .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
1282 
        .collect();
1283 
    let assignees = db::issues::assignees(&app.db, i.id).await?;
1284 
    let milestone = match i.milestone_id {
1285 
        Some(id) => db::issues::milestone(&app.db, id).await?.map(|m| m.title),
1286 
        None => None,
1287 
    };
1288 
    let comments: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM issue_comments WHERE issue_id = ?").bind(i.id).fetch_one(&app.db).await?;
1289 
    Ok(Issue {
1290 
        number: i.number,
1291 
        title: i.title.clone(),
1292 
        body: i.body.clone(),
1293 
        author: i.author.clone(),
1294 
        state: i.state.clone(),
1295 
        reason: i.reason.clone(),
1296 
        labels,
1297 
        assignees,
1298 
        milestone,
1299 
        comments,
1300 
        locked: i.locked,
1301 
        pinned: i.pinned,
1302 
        created_ms: i.created_ms,
1303 
        updated_ms: i.updated_ms,
1304 
        closed_ms: i.closed_ms,
1305 
        url: format!("{}/{}/issue/{}", app.config.base_url(), row.slug(), i.number),
1306 
    })
1307 
}
1308
1309 
#[derive(Deserialize)]
1310 
struct IssuesQuery {
1311 
    state: Option<String>,
1312 
}
1313
1314 
async fn issues(
1315 
    State(app): State<Shared>,
1316 
    headers: HeaderMap,
1317 
    Path((owner, name)): Path<(String, String)>,
1318 
    Query(q): Query<IssuesQuery>,
1319 
) -> Result<Json<Vec<Issue>>, ApiError> {
1320 
    let c = caller(&app, &headers).await?;
1321 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1322 
    let state = q.state.unwrap_or_else(|| "open".into());
1323 
    let mut out = Vec::new();
1324 
    for i in db::issues::list(&app.db, row.id).await? {
1325 
        if state == "all" || i.state == state {
1326 
            out.push(issue_of(&app, &row, &i).await?);
d23464c0 Andy McCall ↶ 1327 
        }
1328 
    }
b64e2537 Andy McCall ↶ 1329 
    Ok(Json(out))
d23464c0 Andy McCall ↶ 1330 
}
1331
b64e2537 Andy McCall ↶ 1332 
async fn create_issue(
1333 
    State(app): State<Shared>,
1334 
    headers: HeaderMap,
1335 
    Path((owner, name)): Path<(String, String)>,
1336 
    Json(body): Json<NewIssue>,
1337 
) -> Result<(StatusCode, Json<Issue>), ApiError> {
1338 
    let c = caller(&app, &headers).await?;
1339 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
76f262e1 Andy McCall ↶ 1340 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
b64e2537 Andy McCall ↶ 1341 
    if body.title.trim().is_empty() {
1342 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
d23464c0 Andy McCall ↶ 1343 
    }
76f262e1 Andy McCall ↶ 1344 
    let triage = !body.labels.is_empty() || !body.assignees.is_empty() || body.milestone.is_some();
1345 
    if triage && role < Role::Triage {
1346 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
1347 
    }
1348 
    // Check the names before anything is created.
1349 
    resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
b64e2537 Andy McCall ↶ 1350 
    let i = db::issues::create(
1351 
        &app.db,
1352 
        db::issues::NewIssue {
1353 
            repo_id: row.id,
1354 
            title: body.title.trim(),
1355 
            body: body.body.trim(),
1356 
            author_id: Some(me.id),
1357 
            author: &me.username,
1358 
        },
1359 
    )
1360 
    .await?;
1361 
    db::issues::add_event(&app.db, i.id, &me.username, "opened", "").await.ok();
76f262e1 Andy McCall ↶ 1362 
    if triage {
1363 
        let t = resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
1364 
        apply_triage(&app, &i, &me, t).await?;
1365 
    }
1366 
    let i = db::issues::get(&app.db, row.id, i.number).await?.unwrap_or(i);
b64e2537 Andy McCall ↶ 1367 
    crate::web::issues::reindex(&app, row.id, &i).await;
1368 
    let api = issue_of(&app, &row, &i).await?;
1369 
    crate::notify::deliver(
1370 
        &app,
1371 
        crate::notify::Event {
1372 
            kind: "issue.opened",
1373 
            title: format!("{owner}/{name}#{}: {}", i.number, i.title),
1374 
            url: format!("/{owner}/{name}/issue/{}", i.number),
1375 
            actor: &me,
1376 
            repo_id: row.id,
1377 
            thread: Some(("issue", i.id)),
1378 
            mention_text: &body.body,
1379 
            direct: vec![],
1380 
        },
1381 
    )
1382 
    .await;
1383 
    crate::hooks::emit(&app, &row, "issue.opened", &me.username, serde_json::json!({ "issue": api })).await;
1384 
    Ok((StatusCode::CREATED, Json(api)))
1385 
}
1386
1387 
async fn issue(
1388 
    State(app): State<Shared>,
1389 
    headers: HeaderMap,
1390 
    Path((owner, name, number)): Path<(String, String, i64)>,
1391 
) -> Result<Json<Issue>, ApiError> {
1392 
    let c = caller(&app, &headers).await?;
1393 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1394 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1395 
    Ok(Json(issue_of(&app, &row, &i).await?))
1396 
}
1397
1398 
async fn issue_state(
1399 
    State(app): State<Shared>,
1400 
    headers: HeaderMap,
1401 
    Path((owner, name, number)): Path<(String, String, i64)>,
1402 
    Json(body): Json<IssueStateChange>,
1403 
) -> Result<Json<Issue>, ApiError> {
1404 
    let c = caller(&app, &headers).await?;
1405 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1406 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1407 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1408 
    if role < Role::Triage && Some(me.id) != i.author_id {
1409 
        return Err(forbidden("only the author or triage may change the state"));
1410 
    }
1411 
    let (state, reason) = match body.state.as_str() {
1412 
        "closed" => ("closed", if body.reason == "not_planned" { "not_planned" } else { "completed" }),
1413 
        "open" => ("open", ""),
1414 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is open or closed".into())),
1415 
    };
1416 
    db::issues::set_state(&app.db, i.id, state, reason).await?;
1417 
    db::issues::add_event(&app.db, i.id, &me.username, if state == "closed" { "closed" } else { "reopened" }, "").await.ok();
1418 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
1419 
    let api = issue_of(&app, &row, &fresh).await?;
1420 
    crate::hooks::emit(
1421 
        &app,
1422 
        &row,
1423 
        if state == "closed" { "issue.closed" } else { "issue.reopened" },
1424 
        &me.username,
1425 
        serde_json::json!({ "issue": api }),
1426 
    )
1427 
    .await;
1428 
    Ok(Json(api))
1429 
}
1430
1431 
async fn issue_comments(
1432 
    State(app): State<Shared>,
1433 
    headers: HeaderMap,
1434 
    Path((owner, name, number)): Path<(String, String, i64)>,
1435 
) -> Result<Json<Vec<Comment>>, ApiError> {
1436 
    let c = caller(&app, &headers).await?;
1437 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1438 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1439 
    Ok(Json(
1440 
        db::issues::comments(&app.db, i.id)
1441 
            .await?
1442 
            .into_iter()
1443 
            .map(|c| Comment {
1444 
                id: c.id,
1445 
                author: c.author,
1446 
                body: c.body,
1447 
                created_ms: c.created_ms,
1448 
                path: None,
1449 
                anchor: None,
c0fac31d Andy McCall ↶ 1450 
                line: None,
b64e2537 Andy McCall ↶ 1451 
                resolved: false,
1452 
            })
1453 
            .collect(),
1454 
    ))
1455 
}
1456
1457 
async fn issue_comment(
1458 
    State(app): State<Shared>,
1459 
    headers: HeaderMap,
1460 
    Path((owner, name, number)): Path<(String, String, i64)>,
1461 
    Json(body): Json<NewComment>,
1462 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
1463 
    let c = caller(&app, &headers).await?;
1464 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1465 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1466 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1467 
    if i.locked && role < Role::Triage {
1468 
        return Err(forbidden("this issue is locked"));
1469 
    }
1470 
    if body.body.trim().is_empty() {
1471 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
1472 
    }
1473 
    let cm = db::issues::add_comment(&app.db, i.id, Some(me.id), &me.username, body.body.trim()).await?;
1474 
    crate::web::issues::reindex(&app, row.id, &i).await;
1475 
    crate::notify::deliver(
1476 
        &app,
1477 
        crate::notify::Event {
1478 
            kind: "issue.comment",
1479 
            title: format!("{owner}/{name}#{number}: {}", i.title),
1480 
            url: format!("/{owner}/{name}/issue/{number}"),
1481 
            actor: &me,
1482 
            repo_id: row.id,
1483 
            thread: Some(("issue", i.id)),
1484 
            mention_text: &body.body,
1485 
            direct: i.author_id.into_iter().collect(),
1486 
        },
1487 
    )
1488 
    .await;
c0fac31d Andy McCall ↶ 1489 
    let api = Comment {
1490 
        id: cm.id,
1491 
        author: cm.author,
1492 
        body: cm.body,
1493 
        created_ms: cm.created_ms,
1494 
        path: None,
1495 
        anchor: None,
1496 
        line: None,
1497 
        resolved: false,
1498 
    };
b64e2537 Andy McCall ↶ 1499 
    crate::hooks::emit(&app, &row, "comment.issue", &me.username, serde_json::json!({ "number": number, "comment": api })).await;
1500 
    Ok((StatusCode::CREATED, Json(api)))
76f262e1 Andy McCall ↶ 1501 
}
1502
1503 
/// Labels, assignees and milestone named in a request, looked up.
1504 
struct Triage {
1505 
    labels: Option<Vec<db::issues::Label>>,
1506 
    assignees: Option<Vec<Account>>,
1507 
    /// `Some(None)` clears the milestone.
1508 
    milestone: Option<Option<db::issues::Milestone>>,
1509 
}
1510
1511 
async fn resolve_triage(
1512 
    app: &Shared,
1513 
    repo_id: i64,
1514 
    labels: Option<&[String]>,
1515 
    assignees: Option<&[String]>,
1516 
    milestone: Option<&str>,
1517 
) -> Result<Triage, ApiError> {
1518 
    let bad = |m: String| ApiError(StatusCode::BAD_REQUEST, m);
1519 
    let labels = match labels {
1520 
        Some(names) => {
1521 
            let mut out = Vec::new();
1522 
            for n in names {
1523 
                out.push(
1524 
                    db::issues::label_by_name(&app.db, repo_id, n.trim())
1525 
                        .await?
1526 
                        .ok_or_else(|| bad(format!("no label {n:?}; create it first")))?,
1527 
                );
1528 
            }
1529 
            Some(out)
1530 
        }
1531 
        None => None,
1532 
    };
1533 
    let assignees = match assignees {
1534 
        Some(names) => {
1535 
            let mut out = Vec::new();
1536 
            for n in names {
1537 
                out.push(db::accounts::account_by_name(&app.db, n.trim()).await?.ok_or_else(|| bad(format!("no account {n:?}")))?);
1538 
            }
1539 
            Some(out)
1540 
        }
1541 
        None => None,
1542 
    };
1543 
    let milestone = match milestone.map(str::trim) {
1544 
        None => None,
1545 
        Some("") => Some(None),
1546 
        Some(title) => Some(Some(
1547 
            db::issues::milestones(&app.db, repo_id)
1548 
                .await?
1549 
                .into_iter()
1550 
                .find(|m| m.title == title)
1551 
                .ok_or_else(|| bad(format!("no milestone {title:?}")))?,
1552 
        )),
1553 
    };
1554 
    Ok(Triage { labels, assignees, milestone })
1555 
}
1556
1557 
/// Make an issue's labels, assignees and milestone what `t` says, with
1558 
/// timeline events for what changed.
1559 
async fn apply_triage(app: &Shared, i: &db::issues::IssueRow, me: &Account, t: Triage) -> Result<(), ApiError> {
1560 
    if let Some(want) = t.labels {
1561 
        let have = db::issues::issue_labels(&app.db, i.id).await?;
1562 
        for l in &have {
1563 
            if !want.iter().any(|w| w.id == l.id) {
1564 
                db::issues::set_issue_label(&app.db, i.id, l.id, false).await?;
1565 
            }
1566 
        }
1567 
        for w in &want {
1568 
            if !have.iter().any(|l| l.id == w.id) {
1569 
                db::issues::set_issue_label(&app.db, i.id, w.id, true).await?;
1570 
            }
1571 
        }
1572 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
1573 
        db::issues::add_event(&app.db, i.id, &me.username, "set labels", &names.join(", ")).await.ok();
1574 
    }
1575 
    if let Some(want) = t.assignees {
1576 
        let have = db::issues::assignees(&app.db, i.id).await?;
1577 
        for name in &have {
1578 
            if !want.iter().any(|a| &a.username == name) {
1579 
                if let Some(a) = db::accounts::account_by_name(&app.db, name).await? {
1580 
                    db::issues::set_assignee(&app.db, i.id, a.id, false).await?;
1581 
                    db::issues::add_event(&app.db, i.id, &me.username, "unassigned", name).await.ok();
1582 
                }
1583 
            }
1584 
        }
1585 
        for a in &want {
1586 
            if !have.contains(&a.username) {
1587 
                db::issues::set_assignee(&app.db, i.id, a.id, true).await?;
1588 
                db::issues::add_event(&app.db, i.id, &me.username, "assigned", &a.username).await.ok();
1589 
            }
1590 
        }
1591 
    }
1592 
    if let Some(m) = t.milestone {
1593 
        db::issues::set_milestone(&app.db, i.id, m.as_ref().map(|m| m.id)).await?;
1594 
        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();
1595 
    }
1596 
    Ok(())
1597 
}
1598
1599 
/// `PATCH /repos/{o}/{n}/issues/{number}`.
1600 
async fn issue_edit(
1601 
    State(app): State<Shared>,
1602 
    headers: HeaderMap,
1603 
    Path((owner, name, number)): Path<(String, String, i64)>,
1604 
    Json(body): Json<IssueEdit>,
1605 
) -> Result<Json<Issue>, ApiError> {
1606 
    let c = caller(&app, &headers).await?;
1607 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1608 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1609 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1610 
    let text = body.title.is_some() || body.body.is_some();
1611 
    let triage = body.labels.is_some() || body.assignees.is_some() || body.milestone.is_some();
1612 
    if text && role < Role::Triage && Some(me.id) != i.author_id {
1613 
        return Err(forbidden("only the author or triage may edit the title and body"));
1614 
    }
1615 
    if triage && role < Role::Triage {
1616 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
1617 
    }
1618 
    if i.locked && role < Role::Triage {
1619 
        return Err(forbidden("this issue is locked"));
1620 
    }
1621 
    let t = resolve_triage(&app, row.id, body.labels.as_deref(), body.assignees.as_deref(), body.milestone.as_deref()).await?;
1622 
    if text {
1623 
        let title = body.title.as_deref().map(str::trim).unwrap_or(&i.title);
1624 
        if title.is_empty() {
1625 
            return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
1626 
        }
1627 
        db::issues::edit(&app.db, i.id, title, body.body.as_deref().unwrap_or(&i.body)).await?;
1628 
        db::issues::add_event(&app.db, i.id, &me.username, "edited", "").await.ok();
1629 
    }
1630 
    apply_triage(&app, &i, &me, t).await?;
1631 
    db::issues::touch(&app.db, i.id).await.ok();
1632 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
1633 
    crate::web::issues::reindex(&app, row.id, &fresh).await;
1634 
    let api = issue_of(&app, &row, &fresh).await?;
1635 
    crate::hooks::emit(&app, &row, "issue.edited", &me.username, serde_json::json!({ "issue": api })).await;
1636 
    Ok(Json(api))
1637 
}
1638
1639 
/// `POST /repos/{o}/{n}/labels` (triage).
1640 
async fn create_label(
1641 
    State(app): State<Shared>,
1642 
    headers: HeaderMap,
1643 
    Path((owner, name)): Path<(String, String)>,
1644 
    Json(body): Json<NewLabel>,
1645 
) -> Result<(StatusCode, Json<Label>), ApiError> {
1646 
    let c = caller(&app, &headers).await?;
1647 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
1648 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1649 
    if role < Role::Triage {
1650 
        return Err(forbidden("labels need triage access"));
1651 
    }
1652 
    let label = body.name.trim();
1653 
    if label.is_empty() || label.len() > 50 {
1654 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a label has a name of 1 to 50 characters".into()));
1655 
    }
1656 
    let colour = match body.colour.as_deref() {
1657 
        Some(c) if c.len() == 7 && c.starts_with('#') && c[1..].chars().all(|x| x.is_ascii_hexdigit()) => c.to_string(),
1658 
        Some(c) => return Err(ApiError(StatusCode::BAD_REQUEST, format!("colour {c:?} is not #rrggbb"))),
1659 
        None => "#5aa8ff".to_string(),
1660 
    };
1661 
    let l = db::issues::upsert_label(&app.db, row.id, label, &colour, body.description.trim()).await?;
1662 
    Ok((StatusCode::CREATED, Json(Label { name: l.name, colour: l.colour, description: l.description })))
1663 
}
1664
1665 
/// `DELETE /repos/{o}/{n}/labels/{label}` (triage).
1666 
async fn delete_label(
1667 
    State(app): State<Shared>,
1668 
    headers: HeaderMap,
1669 
    Path((owner, name, label)): Path<(String, String, String)>,
1670 
) -> Result<StatusCode, ApiError> {
1671 
    let c = caller(&app, &headers).await?;
1672 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
1673 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1674 
    if role < Role::Triage {
1675 
        return Err(forbidden("labels need triage access"));
1676 
    }
1677 
    let l = db::issues::label_by_name(&app.db, row.id, &label).await?.ok_or_else(|| not_found("no such label"))?;
1678 
    db::issues::delete_label(&app.db, l.id).await?;
1679 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 1680 
}
1681
b64e2537 Andy McCall ↶ 1682 
async fn labels(
1683 
    State(app): State<Shared>,
1684 
    headers: HeaderMap,
1685 
    Path((owner, name)): Path<(String, String)>,
1686 
) -> Result<Json<Vec<Label>>, ApiError> {
1687 
    let c = caller(&app, &headers).await?;
1688 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1689 
    Ok(Json(
1690 
        db::issues::labels(&app.db, row.id)
1691 
            .await?
1692 
            .into_iter()
1693 
            .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
1694 
            .collect(),
1695 
    ))
1696 
}
1697
1698 
async fn milestones(
1699 
    State(app): State<Shared>,
1700 
    headers: HeaderMap,
1701 
    Path((owner, name)): Path<(String, String)>,
1702 
) -> Result<Json<Vec<Milestone>>, ApiError> {
1703 
    let c = caller(&app, &headers).await?;
1704 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1705 
    let mut out = Vec::new();
1706 
    for m in db::issues::milestones(&app.db, row.id).await? {
1707 
        let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
1708 
        out.push(Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed });
d23464c0 Andy McCall ↶ 1709 
    }
b64e2537 Andy McCall ↶ 1710 
    Ok(Json(out))
1711 
}
1712
5ea4872f Andy McCall ↶ 1713 
fn milestone_of(m: db::issues::Milestone, open: i64, closed: i64) -> Milestone {
1714 
    Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed }
1715 
}
1716
1717 
/// A due date as `YYYY-MM-DD` (UTC midnight), or the empty string for none.
1718 
fn due_ms_of(due: &str) -> Result<Option<i64>, ApiError> {
1719 
    let due = due.trim();
1720 
    if due.is_empty() {
1721 
        return Ok(None);
1722 
    }
1723 
    time::Date::parse(due, &time::macros::format_description!("[year]-[month]-[day]"))
1724 
        .map(|d| Some(d.midnight().assume_utc().unix_timestamp() * 1000))
1725 
        .map_err(|_| ApiError(StatusCode::BAD_REQUEST, format!("due {due:?} is not YYYY-MM-DD")))
1726 
}
1727
1728 
async fn triage_for_milestones(app: &Shared, headers: &HeaderMap, owner: &str, name: &str) -> Result<db::repos::RepoRow, ApiError> {
1729 
    let c = caller(app, headers).await?;
1730 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
1731 
    let (_, row, role) = reach(app, &c, owner, name, Access::Read).await?;
1732 
    if role < Role::Triage {
1733 
        return Err(forbidden("milestones need triage access"));
1734 
    }
1735 
    Ok(row)
1736 
}
1737
1738 
/// `POST /repos/{o}/{n}/milestones` (triage, oxygenhub#91): create a
1739 
/// milestone, or change the description and due date of the one with
1740 
/// that title.
1741 
async fn create_milestone(
1742 
    State(app): State<Shared>,
1743 
    headers: HeaderMap,
1744 
    Path((owner, name)): Path<(String, String)>,
1745 
    Json(body): Json<NewMilestone>,
1746 
) -> Result<(StatusCode, Json<Milestone>), ApiError> {
1747 
    let row = triage_for_milestones(&app, &headers, &owner, &name).await?;
1748 
    let title = body.title.trim();
1749 
    if title.is_empty() || title.len() > 100 {
1750 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a milestone has a title of 1 to 100 characters".into()));
1751 
    }
1752 
    let due_ms = due_ms_of(body.due.as_deref().unwrap_or(""))?;
1753 
    let m = db::issues::upsert_milestone(&app.db, row.id, title, body.description.trim(), due_ms).await?;
1754 
    let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
1755 
    Ok((StatusCode::CREATED, Json(milestone_of(m, open, closed))))
1756 
}
1757
1758 
/// `PATCH /repos/{o}/{n}/milestones/{title}` (triage): title,
1759 
/// description, due date and state; what is not given stays.
1760 
async fn edit_milestone(
1761 
    State(app): State<Shared>,
1762 
    headers: HeaderMap,
1763 
    Path((owner, name, title)): Path<(String, String, String)>,
1764 
    Json(body): Json<MilestoneEdit>,
1765 
) -> Result<Json<Milestone>, ApiError> {
1766 
    let row = triage_for_milestones(&app, &headers, &owner, &name).await?;
1767 
    let m = db::issues::milestones(&app.db, row.id)
1768 
        .await?
1769 
        .into_iter()
1770 
        .find(|m| m.title == title)
1771 
        .ok_or_else(|| not_found("no such milestone"))?;
1772 
    let new_title = body.title.as_deref().map(str::trim).unwrap_or(&m.title);
1773 
    if new_title.is_empty() || new_title.len() > 100 {
1774 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a milestone has a title of 1 to 100 characters".into()));
1775 
    }
1776 
    let due_ms = match body.due.as_deref() {
1777 
        Some(d) => due_ms_of(d)?,
1778 
        None => m.due_ms,
1779 
    };
1780 
    let description = body.description.as_deref().map(str::trim).unwrap_or(&m.description);
1781 
    if body.title.is_some() || body.description.is_some() || body.due.is_some() {
1782 
        db::issues::update_milestone(&app.db, m.id, new_title, description, due_ms).await?;
1783 
    }
1784 
    if let Some(state) = body.state.as_deref() {
1785 
        match state {
1786 
            "open" | "closed" => db::issues::set_milestone_state(&app.db, m.id, state).await?,
1787 
            other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state {other:?} is open or closed"))),
1788 
        }
1789 
    }
1790 
    let fresh = db::issues::milestone(&app.db, m.id).await?.ok_or_else(|| not_found("no such milestone"))?;
1791 
    let (open, closed) = db::issues::milestone_counts(&app.db, fresh.id).await?;
1792 
    Ok(Json(milestone_of(fresh, open, closed)))
1793 
}
1794
b64e2537 Andy McCall ↶ 1795 
// --------------------------------------------------------- hooks, checks
1796
1797 
fn hook_of(h: &db::hooks::Hook) -> Hook {
1798 
    Hook { id: h.id, url: h.url.clone(), events: h.events.clone(), active: h.active, created_ms: h.created_ms }
1799 
}
1800
1801 
async fn hooks(
1802 
    State(app): State<Shared>,
1803 
    headers: HeaderMap,
1804 
    Path((owner, name)): Path<(String, String)>,
1805 
) -> Result<Json<Vec<Hook>>, ApiError> {
1806 
    let c = caller(&app, &headers).await?;
1807 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
1808 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1809 
    Ok(Json(db::hooks::hooks_for_repo(&app.db, row.id).await?.iter().map(hook_of).collect()))
d23464c0 Andy McCall ↶ 1810 
}
1811
b64e2537 Andy McCall ↶ 1812 
async fn create_hook(
1813 
    State(app): State<Shared>,
1814 
    headers: HeaderMap,
1815 
    Path((owner, name)): Path<(String, String)>,
1816 
    Json(body): Json<NewHook>,
1817 
) -> Result<(StatusCode, Json<Hook>), ApiError> {
1818 
    let c = caller(&app, &headers).await?;
1819 
    let me = c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?.clone();
1820 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1821 
    if !(body.url.starts_with("http://") || body.url.starts_with("https://")) {
1822 
        return Err(ApiError(StatusCode::BAD_REQUEST, "the URL must be http or https".into()));
1823 
    }
1824 
    let h = db::hooks::create_hook(&app.db, Some(row.id), None, &body.url, &body.secret, &body.events).await?;
1825 
    db::accounts::audit(&app.db, Some(&me), "hook.created", &row.slug(), &body.url).await.ok();
1826 
    Ok((StatusCode::CREATED, Json(hook_of(&h))))
d23464c0 Andy McCall ↶ 1827 
}
1828
b64e2537 Andy McCall ↶ 1829 
async fn delete_hook(
1830 
    State(app): State<Shared>,
1831 
    headers: HeaderMap,
1832 
    Path((owner, name, id)): Path<(String, String, i64)>,
1833 
) -> Result<StatusCode, ApiError> {
1834 
    let c = caller(&app, &headers).await?;
1835 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
1836 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1837 
    if db::hooks::hook(&app.db, id).await?.is_some_and(|h| h.repo_id == Some(row.id)) {
1838 
        db::hooks::delete_hook(&app.db, id).await?;
1839 
    }
1840 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 1841 
}
1842
b64e2537 Andy McCall ↶ 1843 
pub fn check_of(c: &db::hooks::Check) -> Check {
1844 
    Check {
1845 
        state: c.state.clone(),
1846 
        name: c.name.clone(),
1847 
        status: CheckStatus::parse(&c.status).unwrap_or(CheckStatus::Queued),
1848 
        summary: c.summary.clone(),
1849 
        url: c.url.clone(),
1850 
        reporter: c.reporter.clone(),
1851 
        seal: if c.seal.is_empty() { None } else { Some(c.seal.clone()) },
1852 
        started_ms: c.started_ms,
1853 
        finished_ms: c.finished_ms,
1854 
    }
961c10be Andy McCall ↶ 1855 
}
1856
1857 
/// `GET /repos/{o}/{n}/checks/required`.
1858 
async fn required_checks(
1859 
    State(app): State<Shared>,
1860 
    headers: HeaderMap,
1861 
    Path((owner, name)): Path<(String, String)>,
1862 
) -> Result<Json<RequiredChecks>, ApiError> {
1863 
    let c = caller(&app, &headers).await?;
1864 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1865 
    Ok(Json(RequiredChecks { names: db::hooks::required_checks(&app.db, row.id).await? }))
1866 
}
1867
1868 
/// `PUT /repos/{o}/{n}/checks/required` (repository admin): the whole list.
1869 
async fn set_required_checks(
1870 
    State(app): State<Shared>,
1871 
    headers: HeaderMap,
1872 
    Path((owner, name)): Path<(String, String)>,
1873 
    Json(body): Json<RequiredChecks>,
1874 
) -> Result<Json<RequiredChecks>, ApiError> {
1875 
    let c = caller(&app, &headers).await?;
1876 
    c.require("repo:admin")?;
1877 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1878 
    let mut names: Vec<String> = body.names.iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()).collect();
1879 
    names.sort();
1880 
    names.dedup();
1881 
    if names.len() > 32 || names.iter().any(|n| n.len() > 100 || n.contains(',')) {
1882 
        return Err(ApiError(StatusCode::BAD_REQUEST, "at most 32 check names, each under 100 characters and without commas".into()));
1883 
    }
1884 
    db::hooks::set_required_checks(&app.db, row.id, &names).await?;
1885 
    db::accounts::audit(&app.db, c.account.as_ref(), "repo.required_checks", &format!("{owner}/{name}"), &names.join(", ")).await.ok();
1886 
    Ok(Json(RequiredChecks { names }))
1edac4b6 Andy McCall ↶ 1887 
}
1888
bf3d0754 Andy McCall ↶ 1889 
fn flow_run_of(
1890 
    app: &Shared,
1891 
    row: &db::repos::RepoRow,
1892 
    r: &db::flow::Run,
1893 
    jobs: Vec<db::flow::Job>,
1894 
    queue: &[db::flow::QueueEntry],
1895 
) -> FlowRun {
90326c96 Andy McCall ↶ 1896 
    FlowRun {
bf3d0754 Andy McCall ↶ 1897 
        queue_position: crate::flow::queue_info(queue, row.id, r.id).position.map(|p| p as i64),
90326c96 Andy McCall ↶ 1898 
        number: r.number,
1899 
        bookmark: r.bookmark.clone(),
1900 
        state: r.state.clone(),
1901 
        heads: r.head_list().into_iter().map(String::from).collect(),
1902 
        status: r.status.clone(),
c889911b Andy McCall ↶ 1903 
        trigger: r.trigger_label(),
90326c96 Andy McCall ↶ 1904 
        actor: r.actor.clone(),
1905 
        pipeline_hash: r.pipeline_hash.clone(),
1906 
        error: r.error.clone(),
1907 
        created_ms: r.created_ms,
1908 
        finished_ms: r.finished_ms,
1909 
        url: format!("{}/{}/{}/flow/{}", app.config.base_url(), row.owner, row.name, r.number),
1910 
        jobs: jobs
1911 
            .into_iter()
1912 
            .map(|j| FlowJob {
1913 
                depends_on: j.depends_on(),
1914 
                name: j.name,
1915 
                status: j.status,
1916 
                runner: j.runner,
1917 
                exit_code: j.exit_code,
1918 
                error: j.error,
1919 
                started_ms: j.started_ms,
1920 
                finished_ms: j.finished_ms,
1921 
                log_lines: j.log_count,
4d2e44d7 Andy McCall ↶ 1922 
                waiting: j.waiting,
501d8b26 Andy McCall ↶ 1923 
                placed: j.placed,
90326c96 Andy McCall ↶ 1924 
            })
1925 
            .collect(),
1926 
    }
1927 
}
1928
1edac4b6 Andy McCall ↶ 1929 
#[derive(Deserialize)]
90326c96 Andy McCall ↶ 1930 
struct RunsPage {
1931 
    /// Runs numbered below this one (the next page).
1932 
    before: Option<i64>,
1933 
    limit: Option<i64>,
1934 
}
1935
1936 
/// `GET /repos/{o}/{n}/flow/runs`: newest first, `?before=N&limit=` (max 100).
1937 
async fn flow_runs(
1938 
    State(app): State<Shared>,
1939 
    headers: HeaderMap,
1940 
    Path((owner, name)): Path<(String, String)>,
1941 
    Query(q): Query<RunsPage>,
1942 
) -> Result<Json<Vec<FlowRun>>, ApiError> {
1943 
    let c = caller(&app, &headers).await?;
1944 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1945 
    let limit = q.limit.unwrap_or(30).clamp(1, 100);
1946 
    let runs = db::flow::runs_by_number(&app.db, row.id, limit, q.before).await?;
bf3d0754 Andy McCall ↶ 1947 
    let queue = if runs.iter().any(|r| r.live()) { db::flow::queue(&app.db).await? } else { vec![] };
1948 
    Ok(Json(runs.iter().map(|r| flow_run_of(&app, &row, r, vec![], &queue)).collect()))
90326c96 Andy McCall ↶ 1949 
}
1950
1951 
/// `GET /repos/{o}/{n}/flow/runs/{number}`: a run with its jobs.
1952 
async fn flow_run(
1953 
    State(app): State<Shared>,
1954 
    headers: HeaderMap,
1955 
    Path((owner, name, number)): Path<(String, String, i64)>,
1956 
) -> Result<Json<FlowRun>, ApiError> {
1957 
    let c = caller(&app, &headers).await?;
1958 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1959 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
1960 
    let jobs = db::flow::jobs(&app.db, run.id).await?;
bf3d0754 Andy McCall ↶ 1961 
    let queue = if run.live() { db::flow::queue(&app.db).await? } else { vec![] };
1962 
    Ok(Json(flow_run_of(&app, &row, &run, jobs, &queue)))
90326c96 Andy McCall ↶ 1963 
}
1964
1965 
#[derive(Deserialize)]
1966 
struct LogPage {
1967 
    /// Lines after this `seq`.
1968 
    #[serde(default)]
1969 
    after: i64,
1970 
    limit: Option<i64>,
1971 
}
1972
1973 
/// `GET /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/log`: `?after=seq&limit=` (max 5000).
1974 
async fn flow_job_log(
1975 
    State(app): State<Shared>,
1976 
    headers: HeaderMap,
1977 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
1978 
    Query(q): Query<LogPage>,
1979 
) -> Result<Json<Vec<FlowLogLine>>, ApiError> {
1980 
    let c = caller(&app, &headers).await?;
1981 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1982 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
1983 
    let j = db::flow::jobs(&app.db, run.id)
1984 
        .await?
1985 
        .into_iter()
1986 
        .find(|j| j.name == job)
1987 
        .ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such job".into()))?;
1988 
    let lines = db::flow::log(&app.db, j.id, q.after, q.limit.unwrap_or(1000).clamp(1, 5000)).await?;
1989 
    Ok(Json(lines.into_iter().map(|l| FlowLogLine { seq: l.seq, t: l.t, stream: l.stream, text: l.text }).collect()))
1990 
}
1991
1992 
#[derive(Deserialize)]
1edac4b6 Andy McCall ↶ 1993 
struct StartRun {
1994 
    /// Default: the repository's default bookmark.
1995 
    #[serde(default)]
1996 
    bookmark: Option<String>,
4f692533 Andy McCall ↶ 1997 
    /// A change's full hash: run the state whose only head it is, instead
1998 
    /// of a bookmark's.
1999 
    #[serde(default)]
2000 
    change: Option<String>,
0650d94e Andy McCall ↶ 2001 
    /// Only these jobs, with what they depend on (oxygenhub#130); default:
2002 
    /// every job a manual run starts.
2003 
    #[serde(default)]
2004 
    jobs: Vec<String>,
1edac4b6 Andy McCall ↶ 2005 
}
2006
2007 
fn started(app: &Shared, row: &db::repos::RepoRow, number: i64) -> (StatusCode, Json<serde_json::Value>) {
2008 
    let url = format!("{}/{}/{}/flow/{number}", app.config.base_url(), row.owner, row.name);
2009 
    (StatusCode::CREATED, Json(serde_json::json!({ "number": number, "url": url })))
2010 
}
2011
2012 
/// `POST /repos/{o}/{n}/flow/runs` (repo:write): run a bookmark's current
4f692533 Andy McCall ↶ 2013 
/// state, or one change's, without moving anything (hub spec §13.2).
1edac4b6 Andy McCall ↶ 2014 
async fn start_flow_run(
2015 
    State(app): State<Shared>,
2016 
    headers: HeaderMap,
2017 
    Path((owner, name)): Path<(String, String)>,
2018 
    Json(body): Json<StartRun>,
2019 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2020 
    let c = caller(&app, &headers).await?;
2021 
    let me = c.require("repo:write")?.clone();
2022 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
0650d94e Andy McCall ↶ 2023 
    let (n, what) = match body.change.clone().filter(|c| !c.trim().is_empty()) {
4f692533 Andy McCall ↶ 2024 
        Some(change) => {
0650d94e Andy McCall ↶ 2025 
            let n = crate::flow::run_change(&app, &row, &change, &me.username, &body.jobs)
2026 
                .await
2027 
                .map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
4f692533 Andy McCall ↶ 2028 
            (n, format!("change {}", change.trim()))
2029 
        }
2030 
        None => {
2031 
            let bookmark = body.bookmark.unwrap_or_else(|| row.default_bookmark.clone());
0650d94e Andy McCall ↶ 2032 
            (
2033 
                crate::flow::run_bookmark(&app, &row, &bookmark, &me.username, &body.jobs)
2034 
                    .await
2035 
                    .map_err(|m| ApiError(StatusCode::CONFLICT, m))?,
2036 
                bookmark,
2037 
            )
4f692533 Andy McCall ↶ 2038 
        }
2039 
    };
2040 
    db::accounts::audit(&app.db, Some(&me), "flow.run", &format!("{owner}/{name}"), &format!("#{n} {what}")).await.ok();
1edac4b6 Andy McCall ↶ 2041 
    Ok(started(&app, &row, n))
2042 
}
2043
2044 
/// `POST /repos/{o}/{n}/flow/runs/{number}/rerun` (repo:write).
2045 
async fn rerun_flow_run(
2046 
    State(app): State<Shared>,
2047 
    headers: HeaderMap,
2048 
    Path((owner, name, number)): Path<(String, String, i64)>,
2049 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2050 
    let c = caller(&app, &headers).await?;
2051 
    let me = c.require("repo:write")?.clone();
2052 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2053 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2054 
    let n = crate::flow::rerun(&app, &row, &run, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2055 
    db::accounts::audit(&app.db, Some(&me), "flow.rerun", &format!("{owner}/{name}"), &format!("#{n} of #{number}")).await.ok();
2056 
    Ok(started(&app, &row, n))
d23464c0 Andy McCall ↶ 2057 
}
2058
745d225d Andy McCall ↶ 2059 
/// `POST /repos/{o}/{n}/flow/runs/{number}/cancel` (repo:write): answers
2060 
/// with the run as it now stands.
2061 
async fn cancel_flow_run(
2062 
    State(app): State<Shared>,
2063 
    headers: HeaderMap,
2064 
    Path((owner, name, number)): Path<(String, String, i64)>,
2065 
) -> Result<Json<serde_json::Value>, ApiError> {
2066 
    let c = caller(&app, &headers).await?;
2067 
    let me = c.require("repo:write")?.clone();
2068 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2069 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2070 
    crate::flow::cancel(&app, &row, &run, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2071 
    db::accounts::audit(&app.db, Some(&me), "flow.cancel", &format!("{owner}/{name}"), &format!("#{number}")).await.ok();
2072 
    Ok(Json(serde_json::json!({ "number": number, "status": "cancelled" })))
2073 
}
2074
b64e2537 Andy McCall ↶ 2075 
/// `POST /repos/{o}/{n}/checks`: any `checks:write` (or write) token may
2076 
/// report; the state hash names what was checked.
2077 
async fn post_check(
2078 
    State(app): State<Shared>,
2079 
    headers: HeaderMap,
2080 
    Path((owner, name)): Path<(String, String)>,
2081 
    Json(body): Json<NewCheck>,
2082 
) -> Result<(StatusCode, Json<Check>), ApiError> {
2083 
    let c = caller(&app, &headers).await?;
2084 
    let me = c.require("checks:write").or_else(|_| c.require("repo:write"))?.clone();
2085 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2086 
    if body.state.len() != 64 || !body.state.chars().all(|ch| ch.is_ascii_hexdigit()) {
2087 
        return Err(ApiError(StatusCode::BAD_REQUEST, "state is a 64-character hex state hash".into()));
2088 
    }
2089 
    if body.name.trim().is_empty() || body.name.len() > 100 {
2090 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a check has a short name".into()));
2091 
    }
2092 
    let ch = db::hooks::upsert_check(
2093 
        &app.db,
2094 
        row.id,
db72849c Andy McCall ↶ 2095 
        db::hooks::CheckReport {
2096 
            state: &body.state,
2097 
            name: body.name.trim(),
2098 
            status: body.status.as_str(),
2099 
            summary: &body.summary,
2100 
            url: &body.url,
2101 
            reporter: Some((me.id, &me.username)),
2102 
            seal: body.seal.as_deref().unwrap_or(""),
2103 
        },
b64e2537 Andy McCall ↶ 2104 
    )
2105 
    .await?;
2106 
    let api = check_of(&ch);
2107 
    app.events.proposal(row.id, ProposalEvent { number: 0, kind: "check".into(), check: Some(api.clone()) });
2108 
    crate::hooks::emit(&app, &row, "check", &me.username, serde_json::json!({ "check": api })).await;
2109 
    Ok((StatusCode::CREATED, Json(api)))
d23464c0 Andy McCall ↶ 2110 
}
2111
b64e2537 Andy McCall ↶ 2112 
async fn checks_for_state(
2113 
    State(app): State<Shared>,
2114 
    headers: HeaderMap,
2115 
    Path((owner, name, state)): Path<(String, String, String)>,
2116 
) -> Result<Json<Vec<Check>>, ApiError> {
2117 
    let c = caller(&app, &headers).await?;
90326c96 Andy McCall ↶ 2118 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2119 
    let state = state_key(&app, &repo, &state).await?;
b64e2537 Andy McCall ↶ 2120 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &state).await?.iter().map(check_of).collect()))
90326c96 Andy McCall ↶ 2121 
}
2122
2123 
/// The state hash checks are keyed by, from what a client has: a state
2124 
/// hash, its heads (full change hashes joined with `+`, or the one head of
2125 
/// a single-head state, which is what `oxy log` shows), or a bookmark.
2126 
async fn state_key(app: &Shared, repo: &RepoName, s: &str) -> Result<String, ApiError> {
2127 
    use oxy_core::hash::{hash_object, ChangeHash, ObjectType};
2128 
    let hexes: Vec<&str> = s.split('+').collect();
2129 
    let all_hashes = hexes.iter().all(|h| h.len() == 64 && h.bytes().all(|b| b.is_ascii_hexdigit()));
2130 
    if all_hashes {
2131 
        let row = db::repos::get(&app.db, &repo.owner, &repo.name).await?.ok_or_else(|| not_found("no such repository"))?;
2132 
        if hexes.len() == 1 && !db::hooks::checks_for_state(&app.db, row.id, s).await?.is_empty() {
2133 
            return Ok(s.to_string());
2134 
        }
2135 
        let heads: Vec<ChangeHash> = hexes.iter().filter_map(|h| ChangeHash::from_hex(h)).collect();
2136 
        return Ok(hash_object(ObjectType::State, &oxy_core::objects::StateObject::new(heads).encode()).to_hex());
2137 
    }
2138 
    let b = s.to_string();
2139 
    let found = app.repos.read(repo, move |r, _| Ok(r.view()?.bookmarks.get(&b).copied())).await?;
2140 
    found.map(|st| st.to_hex()).ok_or_else(|| ApiError(StatusCode::NOT_FOUND, format!("{s:?} is not a state hash, heads or a bookmark")))
d23464c0 Andy McCall ↶ 2141 
}
b66e70b7 Andy McCall ↶ 2142
2143 
// ----------------------------------------------------------------- runners
2144
2145 
/// Site administrators only, with any token of theirs (hub spec §13.2).
2146 
fn require_site_admin(c: &Caller) -> Result<&Account, ApiError> {
2147 
    match c.account.as_ref() {
2148 
        Some(a) if a.is_admin => Ok(a),
2149 
        _ => Err(not_found("no such API route")),
2150 
    }
2151 
}
2152
2153 
async fn runner_of(app: &Shared, r: db::runners::Runner, running: i64) -> hub_api::Runner {
2154 
    let serves = match r.scope_repo_id {
2155 
        Some(id) => db::repos::get_by_id(&app.db, id).await.ok().flatten().map(|p| p.slug()).unwrap_or_default(),
2156 
        None => r.scope_owner.clone(),
2157 
    };
2158 
    hub_api::Runner {
2159 
        id: r.id,
2160 
        status: r.status().to_string(),
2161 
        serves,
2162 
        labels: r.label_list().into_iter().map(String::from).collect(),
2163 
        name: r.name,
2164 
        arch: r.arch,
2165 
        os: r.os,
2166 
        version: r.version,
2167 
        max_jobs: r.max_jobs,
2168 
        memory_mib: r.memory_mib,
2169 
        cpus: r.cpus,
2170 
        key: r.key,
2171 
        source: r.source,
2172 
        last_seen_ms: r.last_seen_ms,
2173 
        running,
2fb70d01 Andy McCall ↶ 2174 
        free_disk_mib: r.free_disk_mib,
2175 
        load_x100: r.load_x100,
2176 
        speed: r.speed,
2177 
        speed_class: r.speed_class,
2178 
        kernel: r.kernel,
b66e70b7 Andy McCall ↶ 2179 
    }
2180 
}
2181
2182 
/// `GET /api/v1/runners`.
2183 
async fn runners(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::Runner>>, ApiError> {
2184 
    let c = caller(&app, &headers).await?;
2185 
    require_site_admin(&c)?;
2186 
    let running: std::collections::HashMap<i64, i64> = db::runners::running(&app.db).await?.into_iter().collect();
2187 
    let mut out = Vec::new();
2188 
    for r in db::runners::list(&app.db).await? {
2189 
        let n = running.get(&r.id).copied().unwrap_or(0);
2190 
        out.push(runner_of(&app, r, n).await);
2191 
    }
2192 
    Ok(Json(out))
2193 
}
2194
2195 
#[derive(Deserialize)]
2196 
struct BeforeQuery {
2197 
    #[serde(default)]
2198 
    before: Option<i64>,
2199 
    #[serde(default)]
2200 
    limit: Option<i64>,
2201 
}
2202
2203 
/// `GET /api/v1/runners/{id}/jobs?before=MS&limit=N`: newest first.
2204 
async fn runner_jobs(
2205 
    State(app): State<Shared>,
2206 
    headers: HeaderMap,
2207 
    Path(id): Path<i64>,
2208 
    Query(q): Query<BeforeQuery>,
2209 
) -> Result<Json<Vec<hub_api::RunnerJob>>, ApiError> {
2210 
    let c = caller(&app, &headers).await?;
2211 
    require_site_admin(&c)?;
2212 
    db::runners::get(&app.db, id).await?.ok_or_else(|| not_found("no such runner"))?;
2213 
    let jobs = db::runners::history(&app.db, id, q.limit.unwrap_or(50).clamp(1, 200), q.before).await?;
2214 
    Ok(Json(
2215 
        jobs.into_iter()
2216 
            .map(|j| hub_api::RunnerJob {
2217 
                repo: format!("{}/{}", j.owner, j.repo),
2218 
                run: j.run_number,
2219 
                job: j.job,
2220 
                status: j.status,
2221 
                started_ms: j.started_ms,
2222 
                finished_ms: j.finished_ms,
2223 
            })
2224 
            .collect(),
2225 
    ))
2226 
}
2227
2228 
/// `GET /api/v1/runners/queue`: running jobs, then queued ones in claim order.
2229 
async fn runner_queue(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::QueueItem>>, ApiError> {
2230 
    let c = caller(&app, &headers).await?;
2231 
    require_site_admin(&c)?;
2232 
    Ok(Json(
2233 
        db::flow::queue(&app.db)
2234 
            .await?
2235 
            .into_iter()
2236 
            .map(|e| hub_api::QueueItem {
2237 
                repo: format!("{}/{}", e.owner, e.name),
2238 
                run: e.run_number,
2239 
                job: e.job,
2240 
                status: e.status,
2241 
                runner: e.runner,
2242 
            })
2243 
            .collect(),
2244 
    ))
2245 
}
7d2eb590 Andy McCall ↶ 2246
2247 
/// `POST .../proposals/{number}/review-requests`: ask an AI assistant the
2248 
/// repository may use to review (hub spec §13.4). Accepted at once; the
2249 
/// answer arrives as a `comment` review via the assistant.
2250 
async fn request_assistant(
2251 
    State(app): State<Shared>,
2252 
    headers: HeaderMap,
2253 
    Path((owner, name, number)): Path<(String, String, i64)>,
2254 
    Json(body): Json<hub_api::AssistantRequest>,
2255 
) -> Result<(StatusCode, Json<hub_api::AssistantRequest>), ApiError> {
2256 
    let c = caller(&app, &headers).await?;
2257 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
2258 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2259 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2260 
    if Some(me.id) != p.author_id && role < Role::Write {
2261 
        return Err(forbidden("only the author or a writer asks for reviews"));
2262 
    }
2263 
    if !p.is_open() {
2264 
        return Err(ApiError(StatusCode::CONFLICT, "the proposal is not open".into()));
2265 
    }
2266 
    let a = crate::assistants::enabled_for_repo(&app.db, &row)
2267 
        .await?
2268 
        .into_iter()
2269 
        .find(|a| a.name.eq_ignore_ascii_case(body.assistant.trim()))
2270 
        .ok_or_else(|| ApiError(StatusCode::UNPROCESSABLE_ENTITY, format!("no assistant called {} here", body.assistant.trim())))?;
2271 
    let asked = hub_api::AssistantRequest { assistant: a.name.clone() };
2272 
    crate::assistants::request_review(&app, &row, &p, &me, a).await.map_err(|e| ApiError(StatusCode::CONFLICT, e))?;
2273 
    Ok((StatusCode::ACCEPTED, Json(asked)))
2274 
}
62ceb2ee Andy McCall ↶ 2275
2276 
// -------------------------------------------------------- assistants (§13.4)
2277
2278 
use crate::levels::At;
2279 
use crate::web::assistants as aa;
2280
2281 
/// The level a repository's assistants live at, for its admins (repo:admin).
2282 
async fn repo_level(app: &Shared, c: &Caller, owner: &str, name: &str) -> Result<(Account, At), ApiError> {
2283 
    let me = c.require("repo:admin")?.clone();
2284 
    let (_, row, _) = reach(app, c, owner, name, Access::Admin).await?;
2285 
    Ok((me, At::repo(&row)))
2286 
}
2287
2288 
/// An organisation's level, for its owners (repo:admin).
2289 
async fn org_level(app: &Shared, c: &Caller, org: &str) -> Result<(Account, At), ApiError> {
2290 
    let me = c.require("repo:admin")?.clone();
2291 
    let o = db::accounts::org_by_name(&app.db, org).await?.ok_or_else(|| not_found("no such organisation"))?;
2292 
    if !auth::roles::is_org_owner(&app.db, &me, o.id).await? {
2293 
        return Err(not_found("no such organisation"));
2294 
    }
2295 
    Ok((me, At::org(&o)))
2296 
}
2297
2298 
/// The site's level, for its administrators.
2299 
fn site_level(c: &Caller) -> Result<(Account, At), ApiError> {
2300 
    Ok((require_site_admin(c)?.clone(), At::site()))
2301 
}
2302
2303 
fn put_outcome(r: Result<String, String>) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2304 
    match r {
2305 
        Ok(msg) => Ok((StatusCode::OK, Json(serde_json::json!({ "ok": msg })))),
2306 
        Err(e) => Err(ApiError(StatusCode::UNPROCESSABLE_ENTITY, e)),
2307 
    }
2308 
}
2309
2310 
macro_rules! assistant_routes {
2311 
    ($list:ident, $put:ident, $del:ident, $prompt:ident, $prompt_put:ident, ($($p:ident: $t:ty),*), $level:expr) => {
2312 
        async fn $list(State(app): State<Shared>, headers: HeaderMap, Path(($($p),*)): Path<($($t),*)>) -> Result<Json<Vec<Assistant>>, ApiError> {
2313 
            let c = caller(&app, &headers).await?;
2314 
            let (_, at) = $level(&app, &c, $(&$p),*).await?;
2315 
            Ok(Json(aa::api_list(&app, &at).await?))
2316 
        }
2317 
        async fn $put(
2318 
            State(app): State<Shared>,
2319 
            headers: HeaderMap,
2320 
            Path(($($p),*)): Path<($($t),*)>,
2321 
            Json(body): Json<NewAssistant>,
2322 
        ) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2323 
            let c = caller(&app, &headers).await?;
2324 
            let (me, at) = $level(&app, &c, $(&$p),*).await?;
2325 
            put_outcome(aa::api_put(&app, &me, &at, body).await?)
2326 
        }
2327 
        async fn $prompt(State(app): State<Shared>, headers: HeaderMap, Path(($($p),*)): Path<($($t),*)>) -> Result<Json<AssistantPrompt>, ApiError> {
2328 
            let c = caller(&app, &headers).await?;
2329 
            let (_, at) = $level(&app, &c, $(&$p),*).await?;
2330 
            Ok(Json(aa::api_prompt(&app, &at).await?))
2331 
        }
2332 
        async fn $prompt_put(
2333 
            State(app): State<Shared>,
2334 
            headers: HeaderMap,
2335 
            Path(($($p),*)): Path<($($t),*)>,
2336 
            Json(body): Json<AssistantPrompt>,
2337 
        ) -> Result<Json<AssistantPrompt>, ApiError> {
2338 
            let c = caller(&app, &headers).await?;
2339 
            let (me, at) = $level(&app, &c, $(&$p),*).await?;
2340 
            aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2341 
            Ok(Json(aa::api_prompt(&app, &at).await?))
2342 
        }
2343 
    };
2344 
}
2345
2346 
assistant_routes!(repo_assistants, repo_assistant_put, _rd, repo_prompt, repo_prompt_put, (owner: String, name: String), repo_level);
2347
2348 
async fn repo_assistant_delete(
2349 
    State(app): State<Shared>,
2350 
    headers: HeaderMap,
2351 
    Path((owner, name, assistant)): Path<(String, String, String)>,
2352 
) -> Result<StatusCode, ApiError> {
2353 
    let c = caller(&app, &headers).await?;
2354 
    let (me, at) = repo_level(&app, &c, &owner, &name).await?;
2355 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
2356 
        Ok(StatusCode::NO_CONTENT)
2357 
    } else {
2358 
        Err(not_found("no such assistant at this level"))
2359 
    }
2360 
}
2361
2362 
async fn org_level_one(app: &Shared, c: &Caller, org: &str) -> Result<(Account, At), ApiError> {
2363 
    org_level(app, c, org).await
2364 
}
2365
2366 
async fn org_assistants(State(app): State<Shared>, headers: HeaderMap, Path(org): Path<String>) -> Result<Json<Vec<Assistant>>, ApiError> {
2367 
    let c = caller(&app, &headers).await?;
2368 
    let (_, at) = org_level_one(&app, &c, &org).await?;
2369 
    Ok(Json(aa::api_list(&app, &at).await?))
2370 
}
2371
2372 
async fn org_assistant_put(
2373 
    State(app): State<Shared>,
2374 
    headers: HeaderMap,
2375 
    Path(org): Path<String>,
2376 
    Json(body): Json<NewAssistant>,
2377 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2378 
    let c = caller(&app, &headers).await?;
2379 
    let (me, at) = org_level_one(&app, &c, &org).await?;
2380 
    put_outcome(aa::api_put(&app, &me, &at, body).await?)
2381 
}
2382
2383 
async fn org_assistant_delete(
2384 
    State(app): State<Shared>,
2385 
    headers: HeaderMap,
2386 
    Path((org, assistant)): Path<(String, String)>,
2387 
) -> Result<StatusCode, ApiError> {
2388 
    let c = caller(&app, &headers).await?;
2389 
    let (me, at) = org_level_one(&app, &c, &org).await?;
2390 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
2391 
        Ok(StatusCode::NO_CONTENT)
2392 
    } else {
2393 
        Err(not_found("no such assistant at this level"))
2394 
    }
2395 
}
2396
2397 
async fn org_prompt(State(app): State<Shared>, headers: HeaderMap, Path(org): Path<String>) -> Result<Json<AssistantPrompt>, ApiError> {
2398 
    let c = caller(&app, &headers).await?;
2399 
    let (_, at) = org_level_one(&app, &c, &org).await?;
2400 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2401 
}
2402
2403 
async fn org_prompt_put(
2404 
    State(app): State<Shared>,
2405 
    headers: HeaderMap,
2406 
    Path(org): Path<String>,
2407 
    Json(body): Json<AssistantPrompt>,
2408 
) -> Result<Json<AssistantPrompt>, ApiError> {
2409 
    let c = caller(&app, &headers).await?;
2410 
    let (me, at) = org_level_one(&app, &c, &org).await?;
2411 
    aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2412 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2413 
}
2414
2415 
async fn site_assistants(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Assistant>>, ApiError> {
2416 
    let c = caller(&app, &headers).await?;
2417 
    let (_, at) = site_level(&c)?;
2418 
    Ok(Json(aa::api_list(&app, &at).await?))
2419 
}
2420
2421 
async fn site_assistant_put(
2422 
    State(app): State<Shared>,
2423 
    headers: HeaderMap,
2424 
    Json(body): Json<NewAssistant>,
2425 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2426 
    let c = caller(&app, &headers).await?;
2427 
    let (me, at) = site_level(&c)?;
2428 
    put_outcome(aa::api_put(&app, &me, &at, body).await?)
2429 
}
2430
2431 
async fn site_assistant_delete(
2432 
    State(app): State<Shared>,
2433 
    headers: HeaderMap,
2434 
    Path(assistant): Path<String>,
2435 
) -> Result<StatusCode, ApiError> {
2436 
    let c = caller(&app, &headers).await?;
2437 
    let (me, at) = site_level(&c)?;
2438 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
2439 
        Ok(StatusCode::NO_CONTENT)
2440 
    } else {
2441 
        Err(not_found("no such assistant at this level"))
2442 
    }
2443 
}
2444
2445 
async fn site_prompt(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<AssistantPrompt>, ApiError> {
2446 
    let c = caller(&app, &headers).await?;
2447 
    let (_, at) = site_level(&c)?;
2448 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2449 
}
2450
2451 
async fn site_prompt_put(
2452 
    State(app): State<Shared>,
2453 
    headers: HeaderMap,
2454 
    Json(body): Json<AssistantPrompt>,
2455 
) -> Result<Json<AssistantPrompt>, ApiError> {
2456 
    let c = caller(&app, &headers).await?;
2457 
    let (me, at) = site_level(&c)?;
2458 
    aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2459 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2460 
}