OXYGENHUB
◆ main oxygenhub / crates / hub / src / api / mod.rs
156.5 KiB · Rust · last changed New repository page in sections, with OxygenFlow, the wiki and a default bookmark 4 hours 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
a22e4aec Andy McCall ↶ 18 
mod approvals;
1c52d940 Andy McCall ↶ 19 
mod attachments;
2e9188ca Andy McCall ↶ 20 
mod backups;
df71c789 Andy McCall ↶ 21 
pub mod device;
1c52d940 Andy McCall ↶ 22 
pub use attachments::image_type as attachment_image_type;
166f6e9b Andy McCall 23 
mod drops;
92a797b2 Andy McCall ↶ 24 
mod images;
ef20fdc1 Andy McCall ↶ 25 
mod projects;
617c2840 Andy McCall ↶ 26 
mod reports;
ef20fdc1 Andy McCall ↶ 27
90326c96 Andy McCall ↶ 28 
/// Any other path under `/api/v1`: a problem document, not the site's page.
e9bfea8e Andy McCall ↶ 29 
/// `GET /api/v1/version`: the hub's version and build, and the Oxygen and
30 
/// OxygenFlow library versions it is built on.
31 
async fn version() -> Json<serde_json::Value> {
32 
    Json(crate::web::home::versions())
33 
}
34
90326c96 Andy McCall ↶ 35 
async fn no_route() -> ApiError {
36 
    ApiError(StatusCode::NOT_FOUND, "no such API route".into())
37 
}
38
17a3a84b Andy McCall ↶ 39 
/// A known route asked with a method it does not take: a problem body
40 
/// rather than axum's empty 405 (oxygenhub#115).
41 
async fn wrong_method(method: axum::http::Method, uri: axum::http::Uri) -> ApiError {
42 
    ApiError(StatusCode::METHOD_NOT_ALLOWED, format!("{} is an API route, but not for {method}", uri.path()))
43 
}
44
5533e91a Andy McCall ↶ 45 
/// The API, with release assets up to `asset_limit` bytes (the web form's
46 
/// limit too; axum's default of 2 MiB refused ordinary builds).
47 
pub fn router(asset_limit: usize) -> Router<Shared> {
d23464c0 Andy McCall ↶ 48 
    Router::new()
90326c96 Andy McCall ↶ 49 
        .fallback(no_route)
026a76d2 Andy McCall ↶ 50 
        .route("/keyless/certify", post(crate::keyless::certify))
8aa5ef38 Andy McCall ↶ 51 
        .route("/agents/grants", get(crate::keyless::grants_list).post(crate::keyless::grants_create))
8dcaeeb8 Andy McCall ↶ 52 
        .route(
53 
            "/repos/{owner}/{name}/terraform/state/{state}",
54 
            axum::routing::any(crate::terraform::state)
55 
                .layer(axum::extract::DefaultBodyLimit::max(crate::terraform::MAX_STATE_BYTES + 4096)),
56 
        )
67523e06 Andy McCall ↶ 57 
        .route("/repos/{owner}/{name}/terraform/state/{state}/versions", axum::routing::get(crate::terraform::versions))
58 
        .route("/repos/{owner}/{name}/terraform/state/{state}/versions/{id}", axum::routing::get(crate::terraform::version))
59 
        .route(
60 
            "/repos/{owner}/{name}/terraform/state/{state}/versions/{id}/restore",
61 
            axum::routing::post(crate::terraform::restore_version),
62 
        )
8aa5ef38 Andy McCall ↶ 63 
        .route("/agents/grants/{id}", axum::routing::delete(crate::keyless::grants_revoke))
42fa9554 Andy McCall ↶ 64 
        .route("/flow/claim", post(crate::flow::claim))
b6b7e4cf Andy McCall ↶ 65 
        .route("/flow/runners/register", post(crate::flow::register))
e9b9619c Andy McCall ↶ 66 
        .route("/flow/runners/heartbeat", post(crate::flow::heartbeat))
8501fd58 Andy McCall ↶ 67 
        .route("/flow/runner/update", get(crate::flow::runner_update).post(crate::flow::report_update))
750579ec Andy McCall ↶ 68 
        .route("/flow/images/missing", post(images::missing).layer(axum::extract::DefaultBodyLimit::max(images::MAX_ASK_BYTES)))
951aed50 Andy McCall ↶ 69 
        .route("/flow/images/held", post(images::held))
a46d15e7 Andy McCall ↶ 70 
        .route("/flow/swarm/announce", post(crate::swarm::announce))
92a797b2 Andy McCall ↶ 71 
        .route("/flow/images/chunks/{hash}", axum::routing::put(images::put_chunk).get(images::get_chunk))
72 
        .route(
73 
            "/flow/images/{hash}",
74 
            axum::routing::put(images::put_manifest).get(images::get_manifest).layer(axum::extract::DefaultBodyLimit::max(64 << 20)),
75 
        )
951aed50 Andy McCall ↶ 76 
        // A runner's manifest of an image only runners hold (oxygenflow#94);
77 
        // a 14 GB image's is about 11 MB.
78 
        .route("/flow/images/{hash}/held", axum::routing::put(images::put_held).layer(axum::extract::DefaultBodyLimit::max(64 << 20)))
42fa9554 Andy McCall ↶ 79 
        .route("/flow/jobs/{id}/log", post(crate::flow::log))
80 
        .route("/flow/jobs/{id}/finish", post(crate::flow::finish))
4d2e44d7 Andy McCall ↶ 81 
        .route("/flow/jobs/{id}/decline", post(crate::flow::decline))
ab4df6aa Andy McCall ↶ 82 
        .route("/flow/jobs/{id}/release", post(crate::flow::release))
a3c8288b Andy McCall ↶ 83 
        .route(
e4203e14 Andy McCall ↶ 84 
            "/flow/jobs/{id}/checkpoint",
85 
            post(crate::flow::save_checkpoint)
86 
                .get(crate::flow::checkpoint)
87 
                .layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
88 
        )
89 
        .route(
a3c8288b Andy McCall ↶ 90 
            "/flow/jobs/{id}/artifacts/{name}",
91 
            post(crate::flow::artifact).layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
92 
        )
cd437c4f Andy McCall ↶ 93 
        .route("/flow/jobs/{id}/inputs/{index}", get(crate::flow::input))
a36bab6b Andy McCall ↶ 94 
        .route(
95 
            "/flow/jobs/{id}/reports/{name}/files",
96 
            post(crate::flow::report_file).layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
97 
        )
ef20fdc1 Andy McCall ↶ 98 
        .route("/projects/{owner}", get(projects::list).post(projects::create))
99 
        .route("/projects/{owner}/{number}", get(projects::board).patch(projects::edit))
17a3a84b Andy McCall ↶ 100 
        .route("/projects/{owner}/{number}/cards", get(projects::cards).post(projects::add_card))
306aec18 Andy McCall ↶ 101 
        .route("/projects/{owner}/{number}/columns", post(projects::add_column))
f2d2776b Andy McCall ↶ 102 
        .route("/projects/{owner}/{number}/charts", get(projects::charts))
306aec18 Andy McCall ↶ 103 
        .route("/projects/{owner}/{number}/columns/{column}", axum::routing::patch(projects::edit_column).delete(projects::remove_column))
456f4197 Andy McCall ↶ 104 
        .route("/projects/{owner}/{number}/cards/move", post(projects::move_cards))
439ecd87 Andy McCall ↶ 105 
        .route("/projects/{owner}/{number}/cards/archive", post(projects::archive_cards))
106 
        .route("/projects/{owner}/{number}/cards/{id}/restore", post(projects::restore_card))
ef20fdc1 Andy McCall ↶ 107 
        .route("/projects/{owner}/{number}/cards/{id}", axum::routing::patch(projects::move_card).delete(projects::remove_card))
ecac6e8d Andy McCall ↶ 108 
        .route("/device/code", post(device::code).delete(device::cancel))
df71c789 Andy McCall ↶ 109 
        .route("/device/token", post(device::token))
b66e70b7 Andy McCall ↶ 110 
        .route("/runners", get(runners))
111 
        .route("/runners/queue", get(runner_queue))
112 
        .route("/runners/{id}/jobs", get(runner_jobs))
b64e2537 Andy McCall ↶ 113 
        .route("/user", get(me))
ecac6e8d Andy McCall ↶ 114 
        .route("/user/repos", get(user_repos))
115 
        .route("/user/orgs", get(user_orgs))
f4e13830 Andy McCall ↶ 116 
        .route("/user/proposals", get(user_proposals))
8f1d76f4 Andy McCall ↶ 117 
        .route("/user/issues", get(user_issues))
a22e4aec Andy McCall ↶ 118 
        .route("/user/authenticators", get(approvals::list).post(approvals::add).delete(approvals::remove))
119 
        .route("/user/approvals", get(approvals::pending))
120 
        .route("/user/approvals/{id}", post(approvals::answer))
4dfa4599 Andy McCall ↶ 121 
        .route("/user/sky", get(user_sky))
3d086bc3 Andy McCall ↶ 122 
        .route("/user/starter", get(user_starter))
123 
        .route("/user/flow/runs", get(user_flow_runs))
5714347a Andy McCall ↶ 124 
        .route("/user/runner-token", post(user_runner_token))
60f11b71 Andy McCall ↶ 125 
        .route("/user/token", axum::routing::delete(revoke_own_token))
aeed63c0 Andy McCall ↶ 126 
        .route("/user/push", axum::routing::put(register_push).delete(forget_push))
e9bfea8e Andy McCall ↶ 127 
        .route("/version", get(version))
42a0ba4b Andy McCall ↶ 128 
        .route("/notifications", get(notifications))
129 
        .route("/notifications/read", post(notifications_read_all))
130 
        .route("/notifications/{id}/read", post(notification_read))
b64e2537 Andy McCall ↶ 131 
        .route("/users/{name}", get(user))
166f6e9b Andy McCall 132 
        .route("/users/{name}/drops", get(drops::of_user))
133 
        .route("/drops", get(drops::mine).post(drops::create))
134 
        .route("/drops/{id}", get(drops::view).patch(drops::edit).delete(drops::delete))
04f9c984 Andy McCall ↶ 135 
        .route("/drops/{id}/fork", post(drops::fork))
1c52d940 Andy McCall ↶ 136 
        .route(
137 
            "/repos/{owner}/{name}/attachments",
138 
            post(attachments::upload).layer(axum::extract::DefaultBodyLimit::max(attachments::ATTACHMENT_MAX + 4096)),
139 
        )
04f9c984 Andy McCall ↶ 140 
        .route("/drops/{id}/star", axum::routing::put(drops::star).delete(drops::unstar))
141 
        .route("/drops/{id}/comments", get(drops::comments).post(drops::add_comment))
142 
        .route("/drops/{id}/comments/{n}", axum::routing::delete(drops::delete_comment))
b64e2537 Andy McCall ↶ 143 
        .route("/orgs/{name}", get(org))
144 
        .route("/search", get(search))
145 
        .route("/repos", get(list_repos).post(create_repo))
d23464c0 Andy McCall ↶ 146 
        .route("/repos/{owner}/{name}", get(get_repo))
147 
        .route("/repos/{owner}/{name}/bookmarks", get(bookmarks))
ba0a55bb Andy McCall ↶ 148 
        .route("/repos/{owner}/{name}/tags", get(tags).post(create_tag))
149 
        .route("/repos/{owner}/{name}/tags/{tag}", axum::routing::delete(withdraw_tag))
f677d627 Andy McCall ↶ 150 
        .route("/repos/{owner}/{name}/consumers", get(consumers))
eb2a3502 Andy McCall ↶ 151 
        .route("/repos/{owner}/{name}/diffusion", get(diffusion).put(set_diffusion))
d3b048b2 Andy McCall ↶ 152 
        .route("/repos/{owner}/{name}/backup", axum::routing::put(set_backup))
2e9188ca Andy McCall ↶ 153 
        .route("/user/backups", get(backups::user_get).put(backups::user_put))
154 
        .route("/user/backups/test", post(backups::user_test))
155 
        .route("/user/backups/run", post(backups::user_run))
156 
        .route("/user/backups/runs", get(backups::user_runs))
157 
        .route("/orgs/{name}/backups", get(backups::org_get).put(backups::org_put))
158 
        .route("/orgs/{name}/backups/test", post(backups::org_test))
159 
        .route("/orgs/{name}/backups/run", post(backups::org_run))
160 
        .route("/orgs/{name}/backups/runs", get(backups::org_runs))
b64e2537 Andy McCall ↶ 161 
        .route("/repos/{owner}/{name}/history/{r}", get(history))
162 
        .route("/repos/{owner}/{name}/changes/{hash}", get(change))
163 
        .route("/repos/{owner}/{name}/tree/{r}", get(tree_root))
164 
        .route("/repos/{owner}/{name}/tree/{r}/{*path}", get(tree))
165 
        .route("/repos/{owner}/{name}/file/{r}/{*path}", get(file))
166 
        .route("/repos/{owner}/{name}/blame/{r}/{*path}", get(blame))
167 
        .route("/repos/{owner}/{name}/conflicts", get(conflicts))
168 
        .route("/repos/{owner}/{name}/trust", get(trust))
df940d75 Andy McCall ↶ 169 
        .route("/repos/{owner}/{name}/releases/trust/{*tag}", get(release_trust))
b64e2537 Andy McCall ↶ 170 
        .route("/repos/{owner}/{name}/pushes", get(pushes))
171 
        .route("/repos/{owner}/{name}/proposals", get(proposals).post(create_proposal))
739a763a Andy McCall ↶ 172 
        .route("/repos/{owner}/{name}/proposals/{number}", get(proposal).patch(edit_proposal))
1f1eb06a Andy McCall ↶ 173 
        .route("/repos/{owner}/{name}/proposals/{number}/land", post(land_proposal))
86a69b53 Andy McCall ↶ 174 
        .route("/repos/{owner}/{name}/proposals/{number}/auto-land", post(auto_land_on).delete(auto_land_off))
b64e2537 Andy McCall ↶ 175 
        .route("/repos/{owner}/{name}/proposals/{number}/comments", get(proposal_comments).post(proposal_comment))
176 
        .route("/repos/{owner}/{name}/proposals/{number}/reviews", get(proposal_reviews).post(proposal_review))
cc1cd197 Andy McCall ↶ 177 
        .route("/repos/{owner}/{name}/proposals/{number}/reviewers", post(request_reviewers))
7d2eb590 Andy McCall ↶ 178 
        .route("/repos/{owner}/{name}/proposals/{number}/review-requests", post(request_assistant))
cc1cd197 Andy McCall ↶ 179 
        .route("/repos/{owner}/{name}/proposals/{number}/reviewers/{username}", axum::routing::delete(withdraw_reviewer))
b64e2537 Andy McCall ↶ 180 
        .route("/repos/{owner}/{name}/proposals/{number}/checks", get(proposal_checks))
3f02e5ea Andy McCall ↶ 181 
        .route("/repos/{owner}/{name}/proposals/{number}/files", get(proposal_files))
70c3d029 Andy McCall ↶ 182 
        .route("/repos/{owner}/{name}/proposals/{number}/diff", get(proposal_diff))
3f02e5ea Andy McCall ↶ 183 
        .route("/repos/{owner}/{name}/proposals/{number}/content/{side}/{*path}", get(proposal_content))
b64e2537 Andy McCall ↶ 184 
        .route("/repos/{owner}/{name}/issues", get(issues).post(create_issue))
76f262e1 Andy McCall ↶ 185 
        .route("/repos/{owner}/{name}/issues/{number}", get(issue).post(issue_state).patch(issue_edit))
b64e2537 Andy McCall ↶ 186 
        .route("/repos/{owner}/{name}/issues/{number}/comments", get(issue_comments).post(issue_comment))
76f262e1 Andy McCall ↶ 187 
        .route("/repos/{owner}/{name}/labels", get(labels).post(create_label))
188 
        .route("/repos/{owner}/{name}/labels/{label}", axum::routing::delete(delete_label))
5ea4872f Andy McCall ↶ 189 
        .route("/repos/{owner}/{name}/milestones", get(milestones).post(create_milestone))
40dd3f86 Andy McCall ↶ 190 
        .route(
191 
            "/repos/{owner}/{name}/coverage",
192 
            get(reports::coverage_list)
193 
                .post(reports::coverage_upload)
194 
                .layer(axum::extract::DefaultBodyLimit::max(crate::coverage::MAX_REPORT + (1 << 20))),
195 
        )
617c2840 Andy McCall ↶ 196 
        .route("/repos/{owner}/{name}/coverage/{id}", get(reports::coverage_one))
197 
        .route("/repos/{owner}/{name}/tests", get(reports::tests_list))
198 
        .route("/repos/{owner}/{name}/tests/{id}", get(reports::tests_one))
5ea4872f Andy McCall ↶ 199 
        .route("/repos/{owner}/{name}/milestones/{title}", axum::routing::patch(edit_milestone))
b64e2537 Andy McCall ↶ 200 
        .route("/repos/{owner}/{name}/hooks", get(hooks).post(create_hook))
62ceb2ee Andy McCall ↶ 201 
        .route("/repos/{owner}/{name}/assistants", get(repo_assistants).post(repo_assistant_put))
202 
        .route("/repos/{owner}/{name}/assistants/prompt", get(repo_prompt).put(repo_prompt_put))
203 
        .route("/repos/{owner}/{name}/assistants/{assistant}", axum::routing::delete(repo_assistant_delete))
204 
        .route("/orgs/{org}/assistants", get(org_assistants).post(org_assistant_put))
205 
        .route("/orgs/{org}/assistants/prompt", get(org_prompt).put(org_prompt_put))
206 
        .route("/orgs/{org}/assistants/{assistant}", axum::routing::delete(org_assistant_delete))
9bbca80f Andy McCall ↶ 207 
        .route("/admin/runner-updates", get(runner_updates))
208 
        .route("/admin/runner-updates/settings", axum::routing::put(runner_update_setting))
209 
        .route("/admin/runner-updates/holds/{version}/lift", post(runner_update_lift))
62ceb2ee Andy McCall ↶ 210 
        .route("/admin/assistants", get(site_assistants).post(site_assistant_put))
211 
        .route("/admin/assistants/prompt", get(site_prompt).put(site_prompt_put))
212 
        .route("/admin/assistants/{assistant}", axum::routing::delete(site_assistant_delete))
b64e2537 Andy McCall ↶ 213 
        .route("/repos/{owner}/{name}/hooks/{id}/delete", post(delete_hook))
214 
        .route("/repos/{owner}/{name}/checks", post(post_check))
90326c96 Andy McCall ↶ 215 
        .route("/repos/{owner}/{name}/flow/runs", get(flow_runs).post(start_flow_run))
216 
        .route("/repos/{owner}/{name}/flow/runs/{number}", get(flow_run))
217 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/log", get(flow_job_log))
fac6853c Andy McCall ↶ 218 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/reports", get(reports::job_reports))
219 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/report", get(reports::job_report_one))
220 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/report/{*path}", get(reports::job_report_file))
221 
        .route("/repos/{owner}/{name}/reports", get(reports::latest_reports))
222 
        .route("/repos/{owner}/{name}/reports/{report}", get(reports::named_report_one))
223 
        .route("/repos/{owner}/{name}/reports/{report}/files/{*path}", get(reports::named_report_file))
1edac4b6 Andy McCall ↶ 224 
        .route("/repos/{owner}/{name}/flow/runs/{number}/rerun", post(rerun_flow_run))
e8fa5369 Andy McCall ↶ 225 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/rerun", post(rerun_flow_job))
745d225d Andy McCall ↶ 226 
        .route("/repos/{owner}/{name}/flow/runs/{number}/cancel", post(cancel_flow_run))
b644e175 Andy McCall ↶ 227 
        .route("/repos/{owner}/{name}/deployments", get(list_deployments))
b1860d60 Andy McCall ↶ 228 
        .route("/repos/{owner}/{name}/flow/runs/{number}/expedite", post(expedite_flow_run))
417184c7 Andy McCall ↶ 229 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/approve", post(approve_flow_job))
230 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/reject", post(reject_flow_job))
47e37402 Andy McCall ↶ 231 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/approval", get(flow_job_statement))
232 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/seal", post(seal_flow_job))
961c10be Andy McCall ↶ 233 
        .route("/repos/{owner}/{name}/checks/required", get(required_checks).put(set_required_checks))
b64e2537 Andy McCall ↶ 234 
        .route("/repos/{owner}/{name}/checks/{state}", get(checks_for_state))
3f4b0ea6 Andy McCall ↶ 235 
        .route("/repos/{owner}/{name}/releases", get(releases).post(create_release))
851a26a2 Andy McCall ↶ 236 
        .route("/repos/{owner}/{name}/sky", get(repo_sky))
3d086bc3 Andy McCall ↶ 237 
        .route("/repos/{owner}/{name}/starter", get(starter_status).post(start_starter))
ced6d3af Andy McCall ↶ 238 
        .route("/repos/{owner}/{name}/releases/{tag}", axum::routing::patch(edit_release))
5533e91a Andy McCall ↶ 239 
        .route(
240 
            "/repos/{owner}/{name}/releases/{tag}/assets",
241 
            post(upload_asset).layer(axum::extract::DefaultBodyLimit::max(asset_limit + (1 << 20))),
242 
        )
17a3a84b Andy McCall ↶ 243 
        // Last: it applies to the routes registered before it.
244 
        .method_not_allowed_fallback(wrong_method)
3f4b0ea6 Andy McCall ↶ 245 
}
246
247 
async fn releases(
248 
    State(app): State<Shared>,
249 
    headers: HeaderMap,
250 
    Path((owner, name)): Path<(String, String)>,
251 
) -> Result<Json<Vec<Release>>, ApiError> {
252 
    let c = caller(&app, &headers).await?;
253 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
254 
    Ok(Json(crate::web::releases::api_views(&app, &repo, &row).await?))
255 
}
256
851a26a2 Andy McCall ↶ 257 
/// `GET /repos/{owner}/{name}/sky` (oxygenhub-android#23): the
258 
/// repository's sky, its pages' backdrop (#196), in the shape of
259 
/// `/user/sky`: the one repository and its events of the last 30 days.
260 
async fn repo_sky(
261 
    State(app): State<Shared>,
262 
    headers: HeaderMap,
263 
    Path((owner, name)): Path<(String, String)>,
264 
) -> Result<Json<hub_api::UserSky>, ApiError> {
265 
    let c = caller(&app, &headers).await?;
266 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
267 
    let now = db::now_ms();
268 
    let since = now - crate::web::home::SKY_DAYS * 86_400_000;
269 
    let events = db::activity::sky(&app.db, &[row.id], since, crate::web::home::SKY_EVENTS).await?;
270 
    Ok(Json(hub_api::UserSky {
271 
        now,
272 
        repos: vec![format!("{}/{}", row.owner, row.name)],
273 
        events: events.iter().map(|e| [0, e.kind, e.at_ms, e.n]).collect(),
274 
    }))
275 
}
276
3f4b0ea6 Andy McCall ↶ 277 
async fn create_release(
278 
    State(app): State<Shared>,
279 
    headers: HeaderMap,
280 
    Path((owner, name)): Path<(String, String)>,
281 
    Json(body): Json<NewRelease>,
282 
) -> Result<(StatusCode, Json<Release>), ApiError> {
283 
    let c = caller(&app, &headers).await?;
284 
    let me = c.require("repo:write")?.clone();
285 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
286 
    crate::web::releases::create_release(&app, &repo, &row, &me, &body.tag, &body.title, body.notes, body.prerelease)
287 
        .await
288 
        .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
289 
    let r = crate::web::releases::api_views(&app, &repo, &row)
290 
        .await?
291 
        .into_iter()
292 
        .find(|r| r.tag == body.tag)
293 
        .ok_or_else(|| not_found("no such release"))?;
294 
    Ok((StatusCode::CREATED, Json(r)))
295 
}
296
ced6d3af Andy McCall ↶ 297 
/// `PATCH …/releases/{tag}` (oxygenhub#72): change a release's title,
298 
/// notes or prerelease flag, as the release page's Edit does.
299 
async fn edit_release(
300 
    State(app): State<Shared>,
301 
    headers: HeaderMap,
302 
    Path((owner, name, tag)): Path<(String, String, String)>,
303 
    Json(body): Json<ReleaseEdit>,
304 
) -> Result<Json<Release>, ApiError> {
305 
    let c = caller(&app, &headers).await?;
306 
    let me = c.require("repo:write")?.clone();
307 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
308 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
309 
    let title = body.title.as_deref().map(str::trim).filter(|t| !t.is_empty()).unwrap_or(&r.title);
310 
    let notes = body.notes.as_deref().map(str::trim).unwrap_or(&r.notes);
311 
    db::releases::edit(&app.db, r.id, title, notes, body.prerelease.unwrap_or(r.prerelease)).await?;
312 
    db::accounts::audit(&app.db, Some(&me), "release.edited", &format!("{owner}/{name}@{tag}"), "").await.ok();
313 
    let r = crate::web::releases::api_views(&app, &repo, &row)
314 
        .await?
315 
        .into_iter()
316 
        .find(|r| r.tag == tag)
317 
        .ok_or_else(|| not_found("no such release"))?;
318 
    Ok(Json(r))
319 
}
320
3f4b0ea6 Andy McCall ↶ 321 
#[derive(Deserialize)]
322 
struct AssetQuery {
323 
    name: String,
de505df5 Andy McCall ↶ 324 
}
325
3f4b0ea6 Andy McCall ↶ 326 
/// `POST …/releases/{tag}/assets?name=file.tar.gz` with the file as the body.
327 
async fn upload_asset(
328 
    State(app): State<Shared>,
329 
    headers: HeaderMap,
330 
    Path((owner, name, tag)): Path<(String, String, String)>,
331 
    Query(q): Query<AssetQuery>,
332 
    body: axum::body::Bytes,
333 
) -> Result<(StatusCode, Json<Release>), ApiError> {
334 
    let c = caller(&app, &headers).await?;
335 
    c.require("repo:write")?;
336 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
337 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
338 
    let ct = headers.get(axum::http::header::CONTENT_TYPE).and_then(|v| v.to_str().ok()).unwrap_or("application/octet-stream").to_string();
339 
    crate::web::releases::store_asset(&app, r.id, &q.name, &ct, &body).await.map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
340 
    let r = crate::web::releases::api_views(&app, &repo, &row)
341 
        .await?
342 
        .into_iter()
343 
        .find(|r| r.tag == tag)
344 
        .ok_or_else(|| not_found("no such release"))?;
345 
    Ok((StatusCode::CREATED, Json(r)))
346 
}
347
42fa9554 Andy McCall ↶ 348 
pub struct ApiError(pub StatusCode, pub String);
b64e2537 Andy McCall ↶ 349
350 
impl IntoResponse for ApiError {
351 
    fn into_response(self) -> Response {
352 
        let body = Problem { status: self.0.as_u16(), title: self.0.canonical_reason().unwrap_or("error").into(), detail: self.1 };
353 
        (self.0, [("content-type", "application/problem+json")], Json(body)).into_response()
de505df5 Andy McCall ↶ 354 
    }
b64e2537 Andy McCall ↶ 355 
}
356
357 
impl From<RepoError> for ApiError {
358 
    fn from(e: RepoError) -> ApiError {
359 
        match e {
360 
            RepoError::NotFound => not_found("no such repository"),
361 
            RepoError::Oxy(oxy_core::repo::RepoError::Msg(m)) => ApiError(StatusCode::NOT_FOUND, m),
362 
            other => ApiError(StatusCode::INTERNAL_SERVER_ERROR, other.to_string()),
363 
        }
364 
    }
365 
}
366
367 
impl From<sqlx::Error> for ApiError {
368 
    fn from(e: sqlx::Error) -> ApiError {
369 
        ApiError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
370 
    }
371 
}
372
ef20fdc1 Andy McCall ↶ 373 
pub(crate) fn not_found(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 374 
    ApiError(StatusCode::NOT_FOUND, what.into())
375 
}
376
ef20fdc1 Andy McCall ↶ 377 
pub(crate) fn forbidden(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 378 
    ApiError(StatusCode::FORBIDDEN, what.into())
379 
}
380
60f11b71 Andy McCall ↶ 381 
/// The address a request came from: the client's, as the proxy reports
382 
/// it when the hub is behind one (`server.behind_proxy`), else the peer's.
383 
/// Only an address's characters are kept, so it is safe to show.
384 
pub fn client_addr(app: &Shared, headers: &HeaderMap, extensions: &axum::http::Extensions) -> String {
385 
    let from_proxy = || {
386 
        ["cf-connecting-ip", "x-forwarded-for", "x-real-ip"]
387 
            .iter()
388 
            .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()))
389 
    };
390 
    let addr = if app.config.server.behind_proxy {
391 
        from_proxy()
392 
    } else {
393 
        extensions.get::<axum::extract::ConnectInfo<std::net::SocketAddr>>().map(|c| c.0.ip().to_string())
394 
    };
395 
    addr.map(|a| a.chars().filter(|c| c.is_ascii_hexdigit() || matches!(c, '.' | ':')).take(45).collect()).unwrap_or_default()
396 
}
397
398 
/// `DELETE /api/v1/user/token`: revoke the token this request is made
399 
/// with, as `oxy auth logout` does.
400 
async fn revoke_own_token(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
401 
    let c = caller(&app, &headers).await?;
402 
    let (Some(account), Some(id)) = (c.account.as_ref(), c.token_id) else {
403 
        return Err(ApiError(StatusCode::UNAUTHORIZED, "revoking needs the personal access token to revoke".into()));
404 
    };
405 
    db::accounts::delete_token(&app.db, account.id, id).await?;
406 
    db::accounts::audit(&app.db, Some(account), "token.revoke", &c.token, "").await.ok();
407 
    Ok(StatusCode::NO_CONTENT)
408 
}
409
aeed63c0 Andy McCall ↶ 410 
#[derive(Deserialize)]
411 
struct PushRegistration {
412 
    /// The phone's Cloud Messaging registration token.
413 
    fcm_token: String,
414 
    /// The phone's X25519 public key, hex: alerts are sealed to it.
415 
    public_key: String,
416 
}
417
418 
/// `PUT /api/v1/user/push` (oxygenhub-android#16): the phone signed in
419 
/// with this token takes alerts, sealed to its key; registering again
420 
/// replaces its registration. It ends with the token.
421 
async fn register_push(
422 
    State(app): State<Shared>,
423 
    headers: HeaderMap,
424 
    Json(r): Json<PushRegistration>,
425 
) -> Result<Json<serde_json::Value>, ApiError> {
426 
    let c = caller(&app, &headers).await?;
427 
    let (Some(account), Some(id)) = (c.account.as_ref(), c.token_id) else {
428 
        return Err(ApiError(StatusCode::UNAUTHORIZED, "a phone registers with the token it signed in with".into()));
429 
    };
430 
    let key = r.public_key.trim().to_ascii_lowercase();
431 
    if key.len() != 64 || hex::decode(&key).is_err() {
432 
        return Err(ApiError(StatusCode::BAD_REQUEST, "public_key is 32 bytes of hex".into()));
433 
    }
434 
    let fcm = r.fcm_token.trim();
435 
    if fcm.is_empty() || fcm.len() > 4096 {
436 
        return Err(ApiError(StatusCode::BAD_REQUEST, "fcm_token is the phone's registration token".into()));
437 
    }
438 
    db::push::register(&app.db, id, account.id, fcm, &key).await?;
439 
    Ok(Json(serde_json::json!({ "alerts": crate::push::enabled(&app) })))
440 
}
441
442 
/// `DELETE /api/v1/user/push`: this phone takes no more alerts.
443 
async fn forget_push(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
444 
    let c = caller(&app, &headers).await?;
445 
    let Some(id) = c.token_id.filter(|_| c.account.is_some()) else {
446 
        return Err(ApiError(StatusCode::UNAUTHORIZED, "a phone unregisters with the token it signed in with".into()));
447 
    };
448 
    db::push::forget(&app.db, id).await?;
449 
    Ok(StatusCode::NO_CONTENT)
450 
}
451
b64e2537 Andy McCall ↶ 452 
/// Who calls: the account behind a bearer token, with the token's scopes.
453 
pub struct Caller {
454 
    pub account: Option<Account>,
455 
    pub scopes: Vec<String>,
456 
    pub site: bool,
0b20f1ec Andy McCall ↶ 457 
    /// The token's name, for records of what a call did.
458 
    pub token: String,
60f11b71 Andy McCall ↶ 459 
    /// The personal access token's id, when one is used.
460 
    pub token_id: Option<i64>,
05f1a85a Andy McCall ↶ 461 
    /// The token is an agent's (oxygenhub#183): what it does says so.
462 
    pub agent: bool,
b64e2537 Andy McCall ↶ 463 
}
464
465 
impl Caller {
466 
    fn has(&self, scope: &str) -> bool {
467 
        self.site
468 
            || self.scopes.iter().any(|s| {
469 
                s == scope
470 
                    || (scope == "repo:read" && (s == "repo:write" || s == "repo:admin"))
471 
                    || (scope == "repo:write" && s == "repo:admin")
472 
            })
473 
    }
474
475 
    fn require(&self, scope: &str) -> Result<&Account, ApiError> {
ecac6e8d Andy McCall ↶ 476 
        // No token is 401, sign in; a token without the scope is 403 (#303).
477 
        let Some(account) = self.account.as_ref() else {
478 
            return Err(ApiError(StatusCode::UNAUTHORIZED, "a personal access token is required: sign in (`oh auth login`)".into()));
479 
        };
b64e2537 Andy McCall ↶ 480 
        if !self.has(scope) {
481 
            return Err(forbidden(&format!("this token lacks the {scope} scope")));
482 
        }
ecac6e8d Andy McCall ↶ 483 
        Ok(account)
b64e2537 Andy McCall ↶ 484 
    }
485 
}
486
487 
pub async fn caller(app: &Shared, headers: &HeaderMap) -> Result<Caller, ApiError> {
0b20f1ec Andy McCall ↶ 488 
    let Some(t) = oxy_server::bearer_token(headers) else {
05f1a85a Andy McCall ↶ 489 
        return Ok(Caller { account: None, scopes: vec![], site: false, token: String::new(), token_id: None, agent: false });
0b20f1ec Andy McCall ↶ 490 
    };
b64e2537 Andy McCall ↶ 491 
    if app.config.auth.push_tokens.iter().any(|x| auth::mac_equal(x, t)) {
492 
        let admin = db::accounts::accounts(&app.db).await?.into_iter().find(|a| a.is_admin);
0b20f1ec Andy McCall ↶ 493 
        return Ok(Caller {
494 
            account: admin,
495 
            scopes: vec!["repo:admin".into(), "user:read".into(), "checks:write".into()],
496 
            site: true,
497 
            token: "site token".into(),
60f11b71 Andy McCall ↶ 498 
            token_id: None,
05f1a85a Andy McCall ↶ 499 
            agent: false,
0b20f1ec Andy McCall ↶ 500 
        });
b64e2537 Andy McCall ↶ 501 
    }
205d8f86 Andy McCall ↶ 502 
    // An agent's grant token (keyless agents, #241, #253): an agent's token
503 
    // of its owner, reading, and writing when the grant lets its keys move
504 
    // references, as it is for the protocol.
505 
    if t.starts_with(crate::keyless::GRANT_TOKEN_PREFIX) {
506 
        let grant = db::accounts::agent_grant_by_token(&app.db, &auth::token_hash(t)).await?.filter(|g| g.live(db::now_ms()));
507 
        let Some(g) = grant else {
508 
            return Err(ApiError(StatusCode::UNAUTHORIZED, "this agent grant is not valid (revoked, ended or unknown)".into()));
509 
        };
510 
        let account = db::accounts::account_by_id(&app.db, g.account_id).await?.filter(|a| !a.blocked());
511 
        db::accounts::touch_agent_grant(&app.db, g.id).await.ok();
512 
        let mut scopes = vec!["repo:read".to_string(), "user:read".to_string()];
513 
        if g.scope.split(',').any(|s| s.trim() == "refs") {
514 
            scopes.push("repo:write".into());
515 
        }
516 
        return Ok(Caller { account, scopes, site: false, token: g.agent.clone(), token_id: None, agent: true });
517 
    }
b64e2537 Andy McCall ↶ 518 
    let token = db::accounts::token_by_hash(&app.db, &auth::token_hash(t)).await?;
de505df5 Andy McCall ↶ 519 
    match token {
b64e2537 Andy McCall ↶ 520 
        Some(tok) if !tok.expired(db::now_ms()) => {
6a178055 Andy McCall ↶ 521 
            let account = db::accounts::account_by_id(&app.db, tok.account_id).await?.filter(|a| !a.blocked());
b64e2537 Andy McCall ↶ 522 
            db::accounts::touch_token(&app.db, tok.id).await.ok();
60f11b71 Andy McCall ↶ 523 
            Ok(Caller {
524 
                account,
525 
                scopes: tok.scope_list().iter().map(|s| s.to_string()).collect(),
526 
                site: false,
527 
                token: tok.name.clone(),
528 
                token_id: Some(tok.id),
05f1a85a Andy McCall ↶ 529 
                agent: tok.agent,
60f11b71 Andy McCall ↶ 530 
            })
b64e2537 Andy McCall ↶ 531 
        }
de505df5 Andy McCall ↶ 532 
        _ => Err(ApiError(StatusCode::UNAUTHORIZED, "unknown or expired token".into())),
533 
    }
534 
}
535
b64e2537 Andy McCall ↶ 536 
fn repository(app: &Shared, r: &db::repos::RepoRow) -> Repository {
537 
    Repository {
538 
        owner: r.owner.clone(),
539 
        name: r.name.clone(),
540 
        description: r.description.clone(),
541 
        default_bookmark: r.default_bookmark.clone(),
542 
        visibility: r.visibility(),
543 
        created_ms: r.created_ms,
544 
        updated_ms: r.updated_ms,
545 
        clone_url: format!("{}/{}/{}", app.config.base_url(), r.owner, r.name),
546 
    }
547 
}
548
549 
/// A repository the caller may reach with `access`, else 404.
617c2840 Andy McCall ↶ 550 
pub(super) async fn reach(
de505df5 Andy McCall ↶ 551 
    app: &Shared,
b64e2537 Andy McCall ↶ 552 
    c: &Caller,
de505df5 Andy McCall ↶ 553 
    owner: &str,
554 
    name: &str,
b64e2537 Andy McCall ↶ 555 
    access: Access,
556 
) -> Result<(RepoName, db::repos::RepoRow, Role), ApiError> {
a0dd06b0 Andy McCall ↶ 557 
    // A wiki (`NAME.wiki`) has no row of its own, so no proposals, issues
558 
    // or runs (oxygenhub#128): say so to those who may read it, rather than
559 
    // that it does not exist.
560 
    if let Some(base) = name.strip_suffix(".wiki") {
561 
        if let Some(row) = db::repos::get(&app.db, owner, base).await? {
562 
            let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
563 
            if auth::roles::allows(role, Access::Read) {
564 
                return Err(not_found(&format!(
565 
                    "{owner}/{name} is the wiki of {owner}/{base}: it is cloned and pushed with oxy, and takes no proposals, \
566 
                     issues or runs; to publish a bookmark, merge it into main (oxy merge BOOKMARK on main) and push main"
567 
                )));
568 
            }
569 
        }
570 
    }
b64e2537 Andy McCall ↶ 571 
    let repo = RepoName::new(owner, name).ok_or_else(|| not_found("no such repository"))?;
572 
    let row = db::repos::get(&app.db, owner, name).await?.ok_or_else(|| not_found("no such repository"))?;
166f6e9b Andy McCall 573 
    // A drop is reached through `/drops` only (#279).
574 
    if row.is_drop() {
575 
        return Err(not_found("no such repository"));
576 
    }
b64e2537 Andy McCall ↶ 577 
    let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
578 
    if !auth::roles::allows(role, access) {
579 
        return Err(not_found("no such repository"));
580 
    }
581 
    Ok((repo, row, role.unwrap_or(Role::Read)))
582 
}
583
584 
fn summary(c: &view::ChangeView) -> ChangeSummary {
585 
    ChangeSummary {
586 
        hash: c.hash.clone(),
587 
        message: if c.body.is_empty() { c.title.clone() } else { format!("{}\n\n{}", c.title, c.body) },
588 
        author: Author {
589 
            name: c.author.name.clone(),
590 
            email: c.author.email.clone(),
591 
            key: c.author.key.clone(),
592 
            account: c.author.account.clone(),
760a7dd3 Andy McCall ↶ 593 
            note: Author::note_for(&c.author.key, &c.author.account),
b64e2537 Andy McCall ↶ 594 
        },
595 
        when_ms: c.when_ms,
596 
        deps: c.deps.clone(),
597 
        head: c.head,
8933faff Andy McCall ↶ 598 
        via: c.via.as_ref().map(|v| Via {
599 
            name: v.name.clone(),
600 
            key: v.key.clone(),
601 
            scope: v.scope.clone(),
602 
            expires_ms: v.expires_ms,
603 
            revoked: v.revoked,
604 
        }),
b64e2537 Andy McCall ↶ 605 
        signature: match &c.signature {
606 
            view::SigView::Unsigned => Signature::Unsigned,
607 
            view::SigView::Valid { key, sealed, revoked, .. } => Signature::Valid { key: key.clone(), sealed: *sealed, revoked: *revoked },
608 
            view::SigView::Invalid(why) => Signature::Invalid { reason: why.clone() },
609 
        },
610 
    }
611 
}
612
613 
// ---------------------------------------------------------------- accounts
614
615 
async fn me(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<User>, ApiError> {
616 
    let c = caller(&app, &headers).await?;
617 
    let a = c.require("user:read")?;
618 
    Ok(Json(user_of(&app, a).await?))
619 
}
620
42a0ba4b Andy McCall ↶ 621 
#[derive(Deserialize)]
622 
struct InboxQuery {
623 
    #[serde(default)]
624 
    limit: Option<i64>,
625 
}
626
627 
/// The caller's inbox; reading and clearing it needs `user:read`, since
628 
/// it touches nothing but the caller's own notifications.
629 
async fn notifications(
630 
    State(app): State<Shared>,
631 
    headers: HeaderMap,
632 
    Query(q): Query<InboxQuery>,
633 
) -> Result<Json<hub_api::Inbox>, ApiError> {
634 
    let c = caller(&app, &headers).await?;
635 
    let a = c.require("user:read")?;
636 
    let limit = q.limit.unwrap_or(50).clamp(1, 200);
637 
    let base = app.config.base_url().trim_end_matches('/').to_string();
ecac6e8d Andy McCall ↶ 638 
    let rows = db::notify::inbox(&app.db, a.id, limit).await?;
639 
    // Repositories by id, each looked up once (#305).
640 
    let mut repos: std::collections::HashMap<i64, Option<String>> = std::collections::HashMap::new();
641 
    for id in rows.iter().filter_map(|n| n.repo_id) {
642 
        if let std::collections::hash_map::Entry::Vacant(e) = repos.entry(id) {
643 
            e.insert(db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", r.owner, r.name)));
644 
        }
645 
    }
646 
    let absolute = |u: String| if u.starts_with('/') { format!("{base}{u}") } else { u };
647 
    let items = rows
42a0ba4b Andy McCall ↶ 648 
        .into_iter()
649 
        .map(|n| hub_api::Notification {
650 
            id: n.id,
651 
            at_ms: n.at_ms,
ecac6e8d Andy McCall ↶ 652 
            label: crate::notify::label(&n.kind).map(String::from),
42a0ba4b Andy McCall ↶ 653 
            kind: n.kind,
654 
            title: n.title,
ecac6e8d Andy McCall ↶ 655 
            url: absolute(n.url),
42a0ba4b Andy McCall ↶ 656 
            actor: n.actor,
657 
            read: n.read,
ecac6e8d Andy McCall ↶ 658 
            repository: n.repo_id.and_then(|id| repos.get(&id).cloned().flatten()),
659 
            reason: n.reason,
660 
            thread: if n.thread.is_empty() { String::new() } else { absolute(n.thread) },
42a0ba4b Andy McCall ↶ 661 
        })
662 
        .collect();
663 
    Ok(Json(hub_api::Inbox { unread: db::notify::unread(&app.db, a.id).await?, items }))
664 
}
665
666 
async fn notification_read(State(app): State<Shared>, headers: HeaderMap, Path(id): Path<i64>) -> Result<StatusCode, ApiError> {
667 
    let c = caller(&app, &headers).await?;
668 
    let a = c.require("user:read")?;
669 
    db::notify::mark_read(&app.db, a.id, Some(id)).await?;
670 
    Ok(StatusCode::NO_CONTENT)
671 
}
672
673 
async fn notifications_read_all(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
674 
    let c = caller(&app, &headers).await?;
675 
    let a = c.require("user:read")?;
676 
    db::notify::mark_read(&app.db, a.id, None).await?;
677 
    Ok(StatusCode::NO_CONTENT)
678 
}
679
b64e2537 Andy McCall ↶ 680 
async fn user_of(app: &Shared, a: &Account) -> Result<User, ApiError> {
681 
    let keys = db::accounts::identities_of(&app.db, a.id).await?.into_iter().map(|i| i.key).collect();
682 
    Ok(User { username: a.username.clone(), display_name: a.display_name.clone(), is_admin: a.is_admin, keys, created_ms: a.created_ms })
683 
}
684
685 
async fn user(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<User>, ApiError> {
686 
    let a = db::accounts::account_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such account"))?;
687 
    Ok(Json(user_of(&app, &a).await?))
688 
}
689
690 
async fn org(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<Organisation>, ApiError> {
691 
    let o = db::accounts::org_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such organisation"))?;
692 
    let members = db::accounts::org_members(&app.db, o.id).await?.into_iter().map(|(a, _)| a.username).collect();
693 
    Ok(Json(Organisation { name: o.name, display_name: o.display_name, description: o.description, members }))
694 
}
695
696 
#[derive(Deserialize)]
697 
struct SearchQuery {
698 
    q: String,
699 
}
700
701 
async fn search(
702 
    State(app): State<Shared>,
703 
    headers: HeaderMap,
704 
    Query(q): Query<SearchQuery>,
705 
) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
706 
    let c = caller(&app, &headers).await?;
707 
    let mut out = Vec::new();
708 
    for h in db::notify::search(&app.db, &q.q, None, 50).await? {
709 
        let Some(row) = db::repos::get_by_id(&app.db, h.repo_id).await? else { continue };
710 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
711 
        if !auth::roles::allows(role, Access::Read) {
712 
            continue;
713 
        }
714 
        out.push(
715 
            serde_json::json!({ "kind": h.kind, "repository": row.slug(), "number": h.number, "title": h.title, "snippet": h.snippet }),
716 
        );
717 
    }
718 
    Ok(Json(out))
719 
}
720
721 
// ------------------------------------------------------------ repositories
722
723 
async fn list_repos(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Repository>>, ApiError> {
724 
    let c = caller(&app, &headers).await?;
725 
    let mut out = Vec::new();
726 
    for r in db::repos::list(&app.db).await? {
727 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &r).await?;
728 
        if auth::roles::allows(role, Access::Read) {
729 
            out.push(repository(&app, &r));
730 
        }
de505df5 Andy McCall ↶ 731 
    }
b64e2537 Andy McCall ↶ 732 
    Ok(Json(out))
ecac6e8d Andy McCall ↶ 733 
}
734
735 
#[derive(Deserialize)]
736 
struct UserReposQuery {
737 
    /// Which: `owner`, `organization`, `collaborator`, comma-separated (all three by default).
738 
    #[serde(default)]
739 
    affiliation: Option<String>,
740 
    /// The last `owner/name` of the previous page.
741 
    #[serde(default)]
742 
    after: Option<String>,
743 
    #[serde(default)]
744 
    limit: Option<usize>,
745 
}
746
747 
/// `GET /user/repos` (#302): the caller's repositories, their
748 
/// organisations' and those they collaborate on, by `owner/name`, a page
749 
/// at a time (`?after=owner/name&limit=`, at most 100, default 50).
5714347a Andy McCall ↶ 750 
/// `POST /user/runner-token` (repo:write): a one-time registration token
751 
/// for a runner that serves the caller's own repositories and no one
752 
/// else's, as a phone registers itself (oxygenhub-android#8). Like the
753 
/// settings pages' tokens it lasts a day.
754 
async fn user_runner_token(State(app): State<Shared>, headers: HeaderMap) -> Result<(StatusCode, Json<RunnerToken>), ApiError> {
755 
    let c = caller(&app, &headers).await?;
756 
    let me = c.require("repo:write")?.clone();
757 
    let token = format!("flowreg_{}", crate::auth::random_hex(24));
758 
    let scope = db::runners::Scope { owner: me.username.clone(), repo_id: None };
759 
    db::runners::add_registration(&app.db, &blake3::hash(token.as_bytes()).to_hex(), &me.username, &scope).await?;
760 
    db::accounts::audit(&app.db, Some(&me), "flow.runner.token", &me.username, "registration token for the caller's repositories (API)")
761 
        .await
762 
        .ok();
763 
    Ok((StatusCode::CREATED, Json(RunnerToken { token, owner: me.username })))
764 
}
765
8f1d76f4 Andy McCall ↶ 766 
/// `GET /user/issues` (repo:read, #359): the open issues assigned to the
767 
/// caller, in repositories it can see, as the dashboard's "Assigned to you".
768 
async fn user_issues(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<IssueBrief>>, ApiError> {
769 
    let c = caller(&app, &headers).await?;
770 
    let me = c.require("repo:read")?.clone();
771 
    let member = db::accounts::visible_repo_ids(&app.db, me.id).await?;
772 
    let seen: Vec<i64> = db::repos::list(&app.db)
773 
        .await?
774 
        .into_iter()
775 
        .filter(|r| me.is_admin || r.visibility() != Visibility::Private || member.contains(&r.id))
776 
        .map(|r| r.id)
777 
        .collect();
778 
    let base = app.config.base_url().trim_end_matches('/').to_string();
779 
    Ok(Json(
780 
        db::activity::assigned(&app.db, me.id, &seen)
781 
            .await?
782 
            .into_iter()
783 
            .map(|i| IssueBrief {
784 
                url: format!("{base}/{}/{}/issue/{}", i.owner, i.name, i.number),
785 
                repository: format!("{}/{}", i.owner, i.name),
786 
                number: i.number,
787 
                title: i.title,
788 
                updated_ms: i.updated_ms,
789 
            })
790 
            .collect(),
791 
    ))
792 
}
793
5d818ec7 Andy McCall ↶ 794 
/// `GET /user/proposals` (repo:read): what the dashboard lists, for apps;
795 
/// with `?landable=true`, also what the caller can land now (#311).
796 
async fn user_proposals(
797 
    State(app): State<Shared>,
798 
    headers: HeaderMap,
799 
    Query(q): Query<UserProposalsQuery>,
800 
) -> Result<Json<UserProposals>, ApiError> {
f4e13830 Andy McCall ↶ 801 
    let c = caller(&app, &headers).await?;
802 
    let me = c.require("repo:read")?.clone();
803 
    // As the dashboard: reviews in repositories the caller belongs to, its
804 
    // own proposals in any it can still see.
805 
    let member = db::accounts::visible_repo_ids(&app.db, me.id).await?;
806 
    let seen: Vec<i64> = db::repos::list(&app.db)
807 
        .await?
808 
        .into_iter()
809 
        .filter(|r| me.is_admin || r.visibility() != Visibility::Private || member.contains(&r.id))
810 
        .map(|r| r.id)
811 
        .collect();
812 
    let base = app.config.base_url().trim_end_matches('/').to_string();
813 
    let brief = |p: db::activity::ProposalLine| ProposalBrief {
814 
        url: format!("{base}/{}/{}/proposal/{}", p.owner, p.name, p.number),
815 
        repository: format!("{}/{}", p.owner, p.name),
816 
        number: p.number,
817 
        title: p.title,
818 
        author: p.author,
819 
        state: match p.state.as_str() {
820 
            "draft" => ProposalState::Draft,
821 
            "landed" => ProposalState::Landed,
822 
            "closed" => ProposalState::Closed,
823 
            _ => ProposalState::Open,
824 
        },
825 
        conflicted: p.conflicted,
826 
        updated_ms: p.updated_ms,
827 
    };
5d818ec7 Andy McCall ↶ 828 
    let landable = if q.landable { landable_for(&app, &c, &member, &base).await? } else { Vec::new() };
f4e13830 Andy McCall ↶ 829 
    Ok(Json(UserProposals {
830 
        review: db::activity::awaiting_review(&app.db, me.id, &member).await?.into_iter().map(brief).collect(),
831 
        authored: db::activity::authored(&app.db, me.id, &seen).await?.into_iter().map(brief).collect(),
5d818ec7 Andy McCall ↶ 832 
        landable,
f4e13830 Andy McCall ↶ 833 
    }))
5d818ec7 Andy McCall ↶ 834 
}
835
836 
/// The open proposals the caller could land now (#311): in repositories
837 
/// it belongs to and can write to, whose verdict has no blockers. Each
838 
/// projected state is worked out four at a time, as `proposals` does
839 
/// (#171); one that cannot be is left out rather than failing the list.
840 
async fn landable_for(app: &Shared, c: &Caller, member: &[i64], base: &str) -> Result<Vec<ProposalBrief>, ApiError> {
841 
    use futures::StreamExt;
842 
    let mut todo = Vec::new();
843 
    for row in db::repos::list(&app.db).await?.into_iter().filter(|r| member.contains(&r.id) && !r.is_drop()) {
844 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
845 
        if !auth::roles::allows(role, Access::Write) {
846 
            continue;
847 
        }
848 
        let Some(repo) = RepoName::new(&row.owner, &row.name) else { continue };
849 
        for p in db::proposals::list(&app.db, row.id, &["open"]).await? {
850 
            todo.push((repo.clone(), row.clone(), p));
851 
        }
852 
    }
853 
    let found: Vec<Option<ProposalBrief>> = futures::stream::iter(todo)
854 
        .map(|(repo, row, p)| {
855 
            let (app, base) = (app.clone(), base.to_string());
856 
            async move {
857 
                let (number, title, author, updated_ms) = (p.number, p.title.clone(), p.author.clone(), p.updated_ms);
858 
                let loaded = crate::web::proposals::load_summary(&app, &repo, p).await.ok()?;
859 
                let v = crate::web::proposals::verdict(&app, &loaded, row.id).await.ok()?;
860 
                v.blockers.is_empty().then(|| ProposalBrief {
861 
                    url: format!("{base}/{}/{}/proposal/{number}", row.owner, row.name),
862 
                    repository: format!("{}/{}", row.owner, row.name),
863 
                    number,
864 
                    title,
865 
                    author,
866 
                    state: ProposalState::Open,
867 
                    conflicted: loaded.conflicted,
868 
                    updated_ms,
869 
                })
870 
            }
871 
        })
872 
        .buffered(4)
873 
        .collect()
874 
        .await;
875 
    Ok(found.into_iter().flatten().collect())
f4e13830 Andy McCall ↶ 876 
}
877
4dfa4599 Andy McCall ↶ 878 
/// `GET /user/sky` (oxygenhub-android#23): Your sky's data for the app,
879 
/// what the web dashboard's backdrop draws: the repositories the caller
880 
/// belongs to and may read, and their events of the last 30 days. Only the
881 
/// database is read, never a repository's store.
882 
async fn user_sky(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<hub_api::UserSky>, ApiError> {
883 
    let c = caller(&app, &headers).await?;
884 
    let me = c.require("repo:read")?.clone();
885 
    let member = db::accounts::visible_repo_ids(&app.db, me.id).await?;
886 
    let mut mine = Vec::new();
887 
    for r in db::repos::list(&app.db).await? {
888 
        if member.contains(&r.id) && auth::roles::allows(auth::roles::role_for(&app.db, Some(&me), &r).await?, Access::Read) {
889 
            mine.push(r);
890 
        }
891 
    }
892 
    mine.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));
893 
    let ids: Vec<i64> = mine.iter().map(|r| r.id).collect();
894 
    let now = db::now_ms();
895 
    let since = now - crate::web::home::SKY_DAYS * 86_400_000;
896 
    let events = db::activity::sky(&app.db, &ids, since, crate::web::home::SKY_EVENTS).await?;
897 
    let events = events.iter().filter_map(|e| Some([ids.iter().position(|&id| id == e.repo_id)? as i64, e.kind, e.at_ms, e.n])).collect();
898 
    Ok(Json(hub_api::UserSky { now, repos: mine.iter().map(|r| format!("{}/{}", r.owner, r.name)).collect(), events }))
899 
}
900
3d086bc3 Andy McCall ↶ 901 
/// `GET /user/flow/runs` (oxygenhub-android#26): the newest runs of the
902 
/// repositories the caller belongs to and may read, each with its jobs,
903 
/// newest first; `before` pages back by creation time.
904 
async fn user_flow_runs(
905 
    State(app): State<Shared>,
906 
    headers: HeaderMap,
907 
    Query(q): Query<hub_api::UserFlowRunsQuery>,
908 
) -> Result<Json<Vec<hub_api::UserFlowRun>>, ApiError> {
909 
    let c = caller(&app, &headers).await?;
910 
    let me = c.require("repo:read")?.clone();
911 
    let member = db::accounts::visible_repo_ids(&app.db, me.id).await?;
912 
    let mut mine = std::collections::HashMap::new();
913 
    for r in db::repos::list(&app.db).await? {
914 
        if member.contains(&r.id) && auth::roles::allows(auth::roles::role_for(&app.db, Some(&me), &r).await?, Access::Read) {
915 
            mine.insert(r.id, r);
916 
        }
917 
    }
918 
    let ids: Vec<i64> = mine.keys().copied().collect();
919 
    let limit = q.limit.unwrap_or(30).clamp(1, 100);
920 
    let runs = db::activity::recent_runs(&app.db, &ids, q.before.unwrap_or(i64::MAX), limit).await?;
921 
    let queue = if runs.iter().any(|r| r.live()) { db::flow::queue(&app.db).await? } else { vec![] };
922 
    let mut out = Vec::with_capacity(runs.len());
923 
    for run in &runs {
924 
        let Some(row) = mine.get(&run.repo_id) else { continue };
925 
        let jobs = db::flow::jobs(&app.db, run.id).await?;
926 
        out.push(hub_api::UserFlowRun {
927 
            repository: format!("{}/{}", row.owner, row.name),
928 
            run: flow_run_of(&app, row, run, jobs, &queue),
929 
        });
930 
    }
931 
    Ok(Json(out))
932 
}
933
934 
#[derive(Deserialize)]
935 
struct StarterQuery {
936 
    owner: String,
937 
}
938
939 
/// `GET /user/starter?owner=X` (#347): the assistants a new repository
940 
/// under `owner` may ask for its starting files, when the caller may
941 
/// create repositories there.
942 
async fn user_starter(
943 
    State(app): State<Shared>,
944 
    headers: HeaderMap,
945 
    Query(q): Query<StarterQuery>,
946 
) -> Result<Json<hub_api::StarterAssistants>, ApiError> {
947 
    let c = caller(&app, &headers).await?;
948 
    let me = c.require("repo:read")?;
949 
    if !auth::roles::may_create_under(&app.db, me, q.owner.trim()).await? {
950 
        return Ok(Json(hub_api::StarterAssistants { assistants: vec![] }));
951 
    }
952 
    let found = crate::starter::assistants_for(&app.db, q.owner.trim()).await?;
953 
    Ok(Json(hub_api::StarterAssistants {
954 
        assistants: found
955 
            .into_iter()
956 
            .map(|a| hub_api::StarterAssistant {
957 
                name: a.assistant.name,
958 
                model: a.assistant.model,
959 
                from: if a.from.is_empty() { "the site".into() } else { a.from },
960 
            })
961 
            .collect(),
962 
    }))
963 
}
964
965 
fn starter_status_of(s: Option<crate::starter::State>) -> hub_api::StarterStatus {
966 
    use crate::starter::State;
967 
    let mut out = hub_api::StarterStatus {
968 
        status: "none".into(),
969 
        assistant: String::new(),
970 
        change: String::new(),
971 
        files: vec![],
972 
        error: String::new(),
973 
    };
974 
    match s {
975 
        None => {}
976 
        Some(State::Running { assistant }) => (out.status, out.assistant) = ("running".into(), assistant),
977 
        Some(State::Done { assistant, change, files }) => {
978 
            (out.status, out.assistant, out.change, out.files) = ("done".into(), assistant, change, files)
979 
        }
980 
        Some(State::Failed { assistant, error }) => (out.status, out.assistant, out.error) = ("failed".into(), assistant, error),
981 
    }
982 
    out
983 
}
984
985 
/// `GET /repos/{owner}/{name}/starter` (#347): where its starter stands.
986 
async fn starter_status(
987 
    State(app): State<Shared>,
988 
    headers: HeaderMap,
989 
    Path((owner, name)): Path<(String, String)>,
990 
) -> Result<Json<hub_api::StarterStatus>, ApiError> {
991 
    let c = caller(&app, &headers).await?;
992 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
993 
    Ok(Json(starter_status_of(crate::starter::state(&app, &repo))))
994 
}
995
996 
/// `POST /repos/{owner}/{name}/starter` (#347): ask an assistant for an
997 
/// empty repository's starting files; `202` while it works, then
998 
/// `GET …/starter` says how it went.
999 
async fn start_starter(
1000 
    State(app): State<Shared>,
1001 
    headers: HeaderMap,
1002 
    Path((owner, name)): Path<(String, String)>,
1003 
    Json(body): Json<hub_api::StarterRequest>,
1004 
) -> Result<(StatusCode, Json<hub_api::StarterStatus>), ApiError> {
1005 
    let c = caller(&app, &headers).await?;
1006 
    let me = c.require("repo:admin")?.clone();
1007 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
1008 
    let description = body.description.trim();
1009 
    if description.is_empty() {
1010 
        return Err(ApiError(StatusCode::UNPROCESSABLE_ENTITY, "say what the repository is for (description)".into()));
1011 
    }
1012 
    if description.chars().count() > crate::starter::MAX_DESCRIPTION {
1013 
        return Err(ApiError(
1014 
            StatusCode::UNPROCESSABLE_ENTITY,
1015 
            format!("a description is at most {} characters", crate::starter::MAX_DESCRIPTION),
1016 
        ));
1017 
    }
1018 
    if matches!(crate::starter::state(&app, &repo), Some(crate::starter::State::Running { .. })) {
1019 
        return Err(ApiError(StatusCode::CONFLICT, "a starter is being drafted for it already".into()));
1020 
    }
1021 
    if !crate::starter::is_empty(&app, &repo, &row.default_bookmark).await.map_err(|e| ApiError(StatusCode::INTERNAL_SERVER_ERROR, e))? {
1022 
        return Err(ApiError(StatusCode::CONFLICT, "the repository has files already; a starter is only for an empty one".into()));
1023 
    }
1024 
    let available = crate::starter::assistants_for(&app.db, &row.owner).await?;
1025 
    let chosen = match body.assistant.as_deref().map(str::trim).filter(|n| !n.is_empty()) {
1026 
        Some(n) => available.into_iter().find(|a| a.assistant.name.eq_ignore_ascii_case(n)),
1027 
        None => available.into_iter().next(),
1028 
    };
1029 
    let Some(a) = chosen else {
1030 
        return Err(ApiError(
1031 
            StatusCode::UNPROCESSABLE_ENTITY,
1032 
            "no assistant is set up for this owner (Admin › Assistants, or the organisation's settings)".into(),
1033 
        ));
1034 
    };
1035 
    if let Err(why) = crate::web::edit::signer_for(&app, me.id).await {
1036 
        return Err(ApiError(StatusCode::UNPROCESSABLE_ENTITY, why));
1037 
    }
1038 
    crate::starter::start(app.clone(), row, me, a.assistant, description.to_string());
1039 
    Ok((StatusCode::ACCEPTED, Json(starter_status_of(crate::starter::state(&app, &repo)))))
1040 
}
1041
ecac6e8d Andy McCall ↶ 1042 
async fn user_repos(
1043 
    State(app): State<Shared>,
1044 
    headers: HeaderMap,
1045 
    Query(q): Query<UserReposQuery>,
1046 
) -> Result<Json<Vec<Repository>>, ApiError> {
1047 
    let c = caller(&app, &headers).await?;
1048 
    let me = c.require("repo:read")?.clone();
1049 
    let wanted: Vec<String> = q
1050 
        .affiliation
1051 
        .as_deref()
1052 
        .unwrap_or("owner,organization,collaborator")
1053 
        .split(',')
1054 
        .map(|s| s.trim().to_ascii_lowercase())
1055 
        .filter(|s| !s.is_empty())
1056 
        .collect();
1057 
    if let Some(bad) = wanted.iter().find(|w| !["owner", "organization", "collaborator"].contains(&w.as_str())) {
1058 
        return Err(ApiError(StatusCode::BAD_REQUEST, format!("unknown affiliation {bad:?}: owner, organization or collaborator")));
1059 
    }
1060 
    let orgs: Vec<String> = db::accounts::orgs_of(&app.db, me.id).await?.into_iter().map(|(o, _)| o.name).collect();
1061 
    let limit = q.limit.unwrap_or(50).clamp(1, 100);
1062 
    let mut rows = db::repos::list(&app.db).await?;
1063 
    rows.sort_by(|a, b| (&a.owner, &a.name).cmp(&(&b.owner, &b.name)));
1064 
    let mut out = Vec::new();
1065 
    for r in rows {
1066 
        if let Some(after) = q.after.as_deref() {
1067 
            if format!("{}/{}", r.owner, r.name).as_str() <= after {
1068 
                continue;
1069 
            }
1070 
        }
1071 
        let mine = (wanted.iter().any(|w| w == "owner") && r.owner == me.username)
1072 
            || (wanted.iter().any(|w| w == "organization") && orgs.contains(&r.owner))
1073 
            || (wanted.iter().any(|w| w == "collaborator") && db::accounts::collaborator_role(&app.db, r.id, me.id).await?.is_some());
1074 
        if !mine || !auth::roles::allows(auth::roles::role_for(&app.db, Some(&me), &r).await?, Access::Read) {
1075 
            continue;
1076 
        }
1077 
        out.push(repository(&app, &r));
1078 
        if out.len() == limit {
1079 
            break;
1080 
        }
1081 
    }
1082 
    Ok(Json(out))
1083 
}
1084
1085 
/// `GET /user/orgs` (#302): the organisations the caller belongs to.
1086 
async fn user_orgs(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::UserOrg>>, ApiError> {
1087 
    let c = caller(&app, &headers).await?;
1088 
    let me = c.require("user:read")?;
1089 
    let orgs = db::accounts::orgs_of(&app.db, me.id).await?;
1090 
    Ok(Json(orgs.into_iter().map(|(o, role)| hub_api::UserOrg { name: o.name, display_name: o.display_name, role }).collect()))
b64e2537 Andy McCall ↶ 1091 
}
1092
1093 
async fn create_repo(
1094 
    State(app): State<Shared>,
1095 
    headers: HeaderMap,
1096 
    Json(body): Json<NewRepository>,
1097 
) -> Result<(StatusCode, Json<Repository>), ApiError> {
1098 
    let c = caller(&app, &headers).await?;
1099 
    let me = c.require("repo:admin")?;
1100 
    let name = RepoName::new(&body.owner, &body.name).ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "invalid owner or name".into()))?;
66fd9d6b Andy McCall ↶ 1101 
    if name.name.ends_with(crate::wiki::SUFFIX) {
1102 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a name cannot end in .wiki: that is the address of a repository's wiki".into()));
1103 
    }
b64e2537 Andy McCall ↶ 1104 
    if !auth::roles::may_create_under(&app.db, me, &name.owner).await? {
1105 
        return Err(forbidden("you cannot create repositories under that owner"));
1106 
    }
1107 
    if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() || app.repos.exists(&name) {
1108 
        return Err(ApiError(StatusCode::CONFLICT, "that repository exists".into()));
1109 
    }
40a43921 Andy McCall ↶ 1110 
    // Its board and starting files, checked before anything is made (#360).
1111 
    use crate::repo_setup::{Board, Start};
1112 
    let board = match &body.project {
1113 
        None => Board::None,
1114 
        Some(p) => match (&p.new, p.number) {
1115 
            (Some(t), None) => Board::New(if t.trim().is_empty() { name.name.clone() } else { t.trim().chars().take(100).collect() }),
1116 
            (None, Some(n)) => Board::Existing(n),
1117 
            _ => return Err(ApiError(StatusCode::BAD_REQUEST, "project is {\"new\": TITLE} or {\"number\": N}".into())),
1118 
        },
1119 
    };
1120 
    crate::repo_setup::check_board(&app, me, &name.owner, &board).await.map_err(|m| ApiError(StatusCode::UNPROCESSABLE_ENTITY, m))?;
1062a0f8 Andy McCall ↶ 1121 
    // OxygenFlow and the wiki with it (#371).
1122 
    let bookmark = body.default_bookmark.clone().unwrap_or_default();
1123 
    if !bookmark.trim().is_empty() {
1124 
        crate::repo_setup::check_bookmark(bookmark.trim()).map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
1125 
    }
1126 
    let flow = crate::repo_setup::Flow::parse(body.flow.as_deref().unwrap_or("")).map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
1127 
    crate::repo_setup::check_flow(&app, me, &name.owner, flow).await.map_err(|m| ApiError(StatusCode::FORBIDDEN, m))?;
40a43921 Andy McCall ↶ 1128 
    let start =
1129 
        Start { readme: body.readme, licence: body.licence.clone().unwrap_or_default(), ignore: body.ignore.clone().unwrap_or_default() };
1130 
    let holder = if me.display_name.trim().is_empty() { me.username.clone() } else { me.display_name.clone() };
1131 
    let files = start
1132 
        .files(&name, &body.description, &holder, time::OffsetDateTime::now_utc().year())
1133 
        .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
1062a0f8 Andy McCall ↶ 1134 
    if !files.is_empty() || body.wiki {
40a43921 Andy McCall ↶ 1135 
        crate::web::edit::signer_for(&app, me.id).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
1136 
    }
15d3f6f7 Andy McCall ↶ 1137 
    app.repos.create_async(&name, None).await?;
b64e2537 Andy McCall ↶ 1138 
    let row = db::repos::create(&app.db, &name.owner, &name.name, &body.description, body.visibility).await?;
1062a0f8 Andy McCall ↶ 1139 
    let row = crate::repo_setup::set_default_bookmark(&app, row, &bookmark).await?;
b64e2537 Andy McCall ↶ 1140 
    db::accounts::audit(&app.db, Some(me), "repo.created", &name.to_string(), "api").await.ok();
40a43921 Andy McCall ↶ 1141 
    crate::repo_setup::link_board(&app, &row, &board, body.visibility == Visibility::Public).await?;
1062a0f8 Andy McCall ↶ 1142 
    crate::repo_setup::set_flow(&app, &row, me, flow).await?;
40a43921 Andy McCall ↶ 1143 
    crate::repo_setup::commit_start(&app, &row, me, files).await.map_err(|m| ApiError(StatusCode::INTERNAL_SERVER_ERROR, m))?;
1062a0f8 Andy McCall ↶ 1144 
    if body.wiki {
1145 
        crate::repo_setup::start_wiki(&app, &row, me, &body.description)
1146 
            .await
1147 
            .map_err(|m| ApiError(StatusCode::INTERNAL_SERVER_ERROR, m))?;
1148 
    }
1149 
    let row = db::repos::get_by_id(&app.db, row.id).await?.unwrap_or(row);
b64e2537 Andy McCall ↶ 1150 
    Ok((StatusCode::CREATED, Json(repository(&app, &row))))
1151 
}
1152
1153 
async fn get_repo(
1154 
    State(app): State<Shared>,
1155 
    headers: HeaderMap,
1156 
    Path((owner, name)): Path<(String, String)>,
1157 
) -> Result<Json<Repository>, ApiError> {
1158 
    let c = caller(&app, &headers).await?;
1159 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1160 
    Ok(Json(repository(&app, &row)))
1161 
}
1162
1163 
async fn bookmarks(
1164 
    State(app): State<Shared>,
1165 
    headers: HeaderMap,
1166 
    Path((owner, name)): Path<(String, String)>,
1167 
) -> Result<Json<Vec<Bookmark>>, ApiError> {
1168 
    let c = caller(&app, &headers).await?;
1169 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1170 
    let default = row.default_bookmark.clone();
1171 
    let list = app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await?;
1172 
    Ok(Json(list.into_iter().map(|b| Bookmark { name: b.name, heads: b.heads, changes: b.changes, default: b.default }).collect()))
1173 
}
1174
e7158350 Andy McCall ↶ 1175 
#[derive(serde::Deserialize)]
d3b048b2 Andy McCall ↶ 1176 
struct BackupSetting {
1177 
    /// `owner` (with its owner's), `hourly`, `daily` or `off`.
1178 
    backup: String,
1179 
}
1180
1181 
/// `PUT /repos/{owner}/{name}/backup {"backup": ...}`: this repository's
1182 
/// backup (docs/backups.md §5). Owners and admins.
1183 
async fn set_backup(
1184 
    State(app): State<Shared>,
1185 
    headers: HeaderMap,
1186 
    Path((owner, name)): Path<(String, String)>,
1187 
    Json(b): Json<BackupSetting>,
1188 
) -> Result<Json<serde_json::Value>, ApiError> {
1189 
    let c = caller(&app, &headers).await?;
1190 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
1191 
    let setting = match b.backup.as_str() {
1192 
        "owner" => "",
1193 
        "hourly" | "daily" | "off" => b.backup.as_str(),
1194 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "backup is owner, hourly, daily or off".into())),
1195 
    };
1196 
    db::repos::set_backup(&app.db, row.id, setting).await?;
1197 
    db::accounts::audit(&app.db, c.account.as_ref(), "repo.backup", &format!("{owner}/{name}"), &b.backup).await.ok();
1198 
    Ok(Json(serde_json::json!({ "backup": b.backup })))
1199 
}
1200
1201 
#[derive(serde::Deserialize)]
e7158350 Andy McCall ↶ 1202 
struct DiffusionSetting {
1203 
    /// `off`, `green`, `any`, or `default` (the site's).
1204 
    follow: String,
f4d6ef41 Andy McCall ↶ 1205 
    /// `auto` or `propose`; absent keeps it as it is.
1206 
    #[serde(default)]
1207 
    land: Option<String>,
e7158350 Andy McCall ↶ 1208 
}
1209
1210 
/// `PUT /repos/{owner}/{name}/diffusion {"follow": ...}`: whether this
1211 
/// repository follows the upstreams it pins (#148). Owners and admins.
1212 
async fn set_diffusion(
1213 
    State(app): State<Shared>,
1214 
    headers: HeaderMap,
1215 
    Path((owner, name)): Path<(String, String)>,
1216 
    Json(d): Json<DiffusionSetting>,
1217 
) -> Result<Json<serde_json::Value>, ApiError> {
1218 
    let c = caller(&app, &headers).await?;
1219 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
1220 
    let setting = match d.follow.as_str() {
1221 
        "off" | "green" | "any" => d.follow.as_str(),
1222 
        "default" => "",
1223 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "follow is off, green, any or default".into())),
f4d6ef41 Andy McCall ↶ 1224 
    };
1225 
    let land = match d.land.as_deref() {
1226 
        Some(l @ ("auto" | "propose")) => Some(l),
1227 
        None => None,
1228 
        Some(_) => return Err(ApiError(StatusCode::BAD_REQUEST, "land is auto or propose".into())),
e7158350 Andy McCall ↶ 1229 
    };
1230 
    db::repos::set_diffusion(&app.db, row.id, setting).await?;
f4d6ef41 Andy McCall ↶ 1231 
    if let Some(l) = land {
1232 
        db::repos::set_diffusion_land(&app.db, row.id, l).await?;
1233 
    }
e7158350 Andy McCall ↶ 1234 
    db::accounts::audit(
1235 
        &app.db,
1236 
        c.account.as_ref(),
1237 
        "repo.diffusion",
1238 
        &format!("{owner}/{name}"),
1239 
        if setting.is_empty() { "default" } else { setting },
1240 
    )
1241 
    .await
1242 
    .ok();
1243 
    let row = db::repos::get_by_id(&app.db, row.id).await?.unwrap_or(row);
1244 
    let rule = crate::diffusion::rule(&app.config.diffusion.follow, &row, None, "");
3776b70d Andy McCall ↶ 1245 
    // Turned on: bumped at once to where its upstreams are (#148).
1246 
    if rule.follow != crate::diffusion::Follow::Off {
1247 
        let (app, row) = (app.clone(), row.clone());
1248 
        tokio::spawn(async move { crate::diffusion::catch_up(&app, &row).await });
1249 
    }
f4d6ef41 Andy McCall ↶ 1250 
    if land == Some("auto") {
1251 
        let (app, row) = (app.clone(), row.clone());
1252 
        tokio::spawn(async move { crate::diffusion::land_ready(&app, &row).await });
1253 
    }
1254 
    Ok(Json(
1255 
        serde_json::json!({ "follow": rule.follow, "from": rule.from, "land": if row.diffusion_land == "auto" { "auto" } else { "propose" } }),
1256 
    ))
e7158350 Andy McCall ↶ 1257 
}
1258
f677d627 Andy McCall ↶ 1259 
/// `GET /repos/{owner}/{name}/consumers`: the repositories that pin this
1260 
/// one as a subrepo and that the caller may read, each with its pin and
1261 
/// how far behind this repository's default bookmark it is (#148).
1262 
async fn consumers(
1263 
    State(app): State<Shared>,
1264 
    headers: HeaderMap,
1265 
    Path((owner, name)): Path<(String, String)>,
1266 
) -> Result<Json<Vec<crate::diffusion::Consumer>>, ApiError> {
1267 
    let c = caller(&app, &headers).await?;
1268 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1269 
    Ok(Json(crate::diffusion::consumers(&app, &row, c.account.as_ref()).await?))
1270 
}
1271
eb2a3502 Andy McCall ↶ 1272 
/// `GET /repos/{owner}/{name}/diffusion`: what this repository takes from
1273 
/// and what it diffuses to, as its Diffusion tab shows them (#153).
1274 
async fn diffusion(
1275 
    State(app): State<Shared>,
1276 
    headers: HeaderMap,
1277 
    Path((owner, name)): Path<(String, String)>,
1278 
) -> Result<Json<hub_api::Diffusion>, ApiError> {
1279 
    let c = caller(&app, &headers).await?;
1280 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1281 
    let slug = format!("{owner}/{name}");
1282 
    let takes_from = crate::diffusion::follows(&app, &row, c.account.as_ref())
1283 
        .await
1284 
        .iter()
1285 
        .map(|(up, p)| p.api(&format!("{}/{}", up.owner, up.name)))
1286 
        .collect();
1287 
    let diffuses_to = crate::diffusion::consumers(&app, &row, c.account.as_ref()).await?.iter().map(|p| p.api(&slug)).collect();
1288 
    Ok(Json(hub_api::Diffusion { takes_from, diffuses_to }))
1289 
}
1290
b64e2537 Andy McCall ↶ 1291 
async fn tags(
1292 
    State(app): State<Shared>,
1293 
    headers: HeaderMap,
1294 
    Path((owner, name)): Path<(String, String)>,
1295 
) -> Result<Json<Vec<Tag>>, ApiError> {
1296 
    let c = caller(&app, &headers).await?;
1297 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1298 
    let list = app.repos.read(&repo, |r, _| view::tags(r)).await?;
1299 
    Ok(Json(list.into_iter().map(|t| Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer }).collect()))
1300 
}
1301
ba0a55bb Andy McCall ↶ 1302 
/// `POST …/tags` (#295): what the Tags page's Create does.
1303 
async fn create_tag(
1304 
    State(app): State<Shared>,
1305 
    headers: HeaderMap,
1306 
    Path((owner, name)): Path<(String, String)>,
1307 
    Json(body): Json<NewTag>,
1308 
) -> Result<(StatusCode, Json<Tag>), ApiError> {
1309 
    let c = caller(&app, &headers).await?;
1310 
    let me = c.require("repo:write")?.clone();
1311 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
1312 
    let made = crate::tags::create(
1313 
        &app,
1314 
        &row,
1315 
        &repo,
1316 
        &me,
1317 
        &body.name,
1318 
        body.target.as_deref().unwrap_or(""),
1319 
        body.message.as_deref().unwrap_or(""),
1320 
    )
1321 
    .await
1322 
    .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
1323 
    let t = app
1324 
        .repos
1325 
        .read(&repo, |r, _| view::tags(r))
1326 
        .await?
1327 
        .into_iter()
1328 
        .find(|t| t.name == made.name)
1329 
        .ok_or_else(|| not_found("no such tag"))?;
1330 
    Ok((StatusCode::CREATED, Json(Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer })))
1331 
}
1332
1333 
#[derive(Deserialize)]
1334 
struct WithdrawQuery {
1335 
    #[serde(default)]
1336 
    reason: String,
1337 
}
1338
1339 
/// `DELETE …/tags/{tag}?reason=…` (#301): what the Tags page's Withdraw
1340 
/// does. Maintainers; refused (409) while a release uses the tag.
1341 
async fn withdraw_tag(
1342 
    State(app): State<Shared>,
1343 
    headers: HeaderMap,
1344 
    Path((owner, name, tag)): Path<(String, String, String)>,
1345 
    Query(q): Query<WithdrawQuery>,
1346 
) -> Result<StatusCode, ApiError> {
1347 
    let c = caller(&app, &headers).await?;
1348 
    let me = c.require("repo:write")?.clone();
1349 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
1350 
    if db::releases::get(&app.db, row.id, &tag).await?.is_some() {
1351 
        return Err(ApiError(StatusCode::CONFLICT, format!("a release uses {tag}: delete the release first")));
1352 
    }
1353 
    crate::tags::withdraw(&app, &row, &repo, &me, &tag, &q.reason).await.map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
1354 
    Ok(StatusCode::NO_CONTENT)
1355 
}
1356
b64e2537 Andy McCall ↶ 1357 
#[derive(Deserialize)]
1358 
struct HistoryQuery {
1359 
    path: Option<String>,
1360 
    offset: Option<usize>,
1361 
    limit: Option<usize>,
f28389bd Andy McCall ↶ 1362 
    /// A revset (Oxygen's docs/revset_query_language.md) in place of the
1363 
    /// reference's whole history; the reference still gives the labels.
1364 
    r: Option<String>,
b64e2537 Andy McCall ↶ 1365 
}
1366
1367 
async fn history(
1368 
    State(app): State<Shared>,
1369 
    headers: HeaderMap,
1370 
    Path((owner, name, r)): Path<(String, String, String)>,
1371 
    Query(q): Query<HistoryQuery>,
1372 
) -> Result<Json<History>, ApiError> {
1373 
    let c = caller(&app, &headers).await?;
1374 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1375 
    let (offset, limit) = (q.offset.unwrap_or(0), q.limit.unwrap_or(50).min(500));
f28389bd Andy McCall ↶ 1376 
    let revset = q.r.clone().filter(|s| !s.trim().is_empty());
1377 
    let by_revset = revset.is_some();
b64e2537 Andy McCall ↶ 1378 
    let h = app
1379 
        .repos
1380 
        .read(&repo, move |repo, cache| {
1381 
            let target = view::resolve(repo, cache, &r)?;
f28389bd Andy McCall ↶ 1382 
            match &revset {
1383 
                Some(rs) => view::history_revset(repo, cache, target, rs, offset, limit),
1384 
                None => view::history(repo, cache, target, q.path.as_deref(), offset, limit),
1385 
            }
b64e2537 Andy McCall ↶ 1386 
        })
f28389bd Andy McCall ↶ 1387 
        .await
1388 
        .map_err(|e| {
1389 
            // A revset that does not parse, names nothing, or goes past the
1390 
            // budget is the caller's to fix.
1391 
            if by_revset {
1392 
                ApiError(StatusCode::BAD_REQUEST, e.to_string())
1393 
            } else {
1394 
                e.into()
1395 
            }
1396 
        })?;
b64e2537 Andy McCall ↶ 1397 
    let mut entries = h.entries;
1398 
    crate::web::attribute(&app, &mut entries.iter_mut().collect::<Vec<_>>()).await;
1399 
    Ok(Json(History {
1400 
        reference: h.target.label,
1401 
        heads: h.target.heads.iter().map(|x| x.to_hex()).collect(),
1402 
        total: h.total,
1403 
        offset: h.offset,
1404 
        changes: entries.iter().map(summary).collect(),
1405 
    }))
1406 
}
1407
1408 
async fn change(
1409 
    State(app): State<Shared>,
1410 
    headers: HeaderMap,
1411 
    Path((owner, name, hash)): Path<(String, String, String)>,
1412 
) -> Result<Json<ChangeDetail>, ApiError> {
1413 
    let c = caller(&app, &headers).await?;
1414 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1415 
    let d = app
1416 
        .repos
1417 
        .read(&repo, move |repo, cache| {
1418 
            let h = view::resolve_change(repo, cache, &hash)?;
1419 
            view::change(repo, cache, &h)
1420 
        })
1421 
        .await?;
1422 
    let mut v = d.view;
1423 
    crate::web::attribute(&app, &mut [&mut v]).await;
d2263e29 Andy McCall ↶ 1424 
    let files = crate::web::history::render_files(&d.files, &d.bases).into_iter().map(file_change).collect();
b64e2537 Andy McCall ↶ 1425 
    Ok(Json(ChangeDetail {
1426 
        body: v.body.clone(),
1427 
        change: summary(&v),
1428 
        dependents: d.dependents.iter().map(|x| x.hash.clone()).collect(),
1429 
        in_bookmarks: d.in_bookmarks,
1430 
        in_tags: d.in_tags,
1431 
        files,
1432 
    }))
d2263e29 Andy McCall ↶ 1433 
}
1434
1435 
fn file_change(f: crate::web::history::FileRows) -> FileChange {
1436 
    use crate::render::diff::Kind;
1437 
    let truncated = f.lines.len() > hub_api::DIFF_LINES;
1438 
    let lines = f
1439 
        .lines
1440 
        .into_iter()
1441 
        .take(hub_api::DIFF_LINES)
1442 
        .map(|l| DiffLine {
1443 
            kind: match l.kind {
1444 
                Kind::Context => "context",
1445 
                Kind::Add => "add",
1446 
                Kind::Del => "del",
1447 
                Kind::Gap => "gap",
1448 
            }
1449 
            .into(),
1450 
            old: l.old_no,
1451 
            new: l.new_no,
1452 
            text: l.text,
1453 
        })
1454 
        .collect();
1455 
    FileChange { path: f.path, kind: f.kind, from: f.from, added: f.added, removed: f.removed, lines, truncated }
b64e2537 Andy McCall ↶ 1456 
}
1457
1458 
fn entry(e: &view::Entry) -> TreeEntry {
1459 
    TreeEntry {
1460 
        name: e.name.clone(),
1461 
        path: e.path.clone(),
1462 
        kind: match e.kind {
1463 
            view::EntryKind::Dir => "dir",
1464 
            view::EntryKind::File => "file",
1465 
            view::EntryKind::Symlink => "symlink",
1466 
            view::EntryKind::Subrepo => "subrepo",
1467 
        }
1468 
        .into(),
1469 
        exec: e.exec,
1470 
        size: e.size,
1471 
        conflicted: e.conflicted,
1472 
    }
1473 
}
1474
1475 
async fn tree_root(
1476 
    State(app): State<Shared>,
1477 
    headers: HeaderMap,
1478 
    Path((owner, name, r)): Path<(String, String, String)>,
1479 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
1480 
    tree(State(app), headers, Path((owner, name, r, String::new()))).await
1481 
}
1482
1483 
async fn tree(
1484 
    State(app): State<Shared>,
1485 
    headers: HeaderMap,
1486 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
1487 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
1488 
    let c = caller(&app, &headers).await?;
1489 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1490 
    let t = app
1491 
        .repos
1492 
        .read(&repo, move |repo, cache| {
1493 
            let target = view::resolve(repo, cache, &r)?;
1494 
            view::tree(repo, cache, target, &path)
1495 
        })
1496 
        .await?;
1497 
    Ok(Json(t.entries.iter().map(entry).collect()))
1498 
}
1499
1500 
async fn file(
1501 
    State(app): State<Shared>,
1502 
    headers: HeaderMap,
1503 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
1504 
) -> Result<Response, ApiError> {
1505 
    let c = caller(&app, &headers).await?;
1506 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1507 
    let limit = app.config.limits.render_limit.0;
1508 
    let f = app
1509 
        .repos
1510 
        .read(&repo, move |repo, cache| {
1511 
            let target = view::resolve(repo, cache, &r)?;
1512 
            view::file(repo, cache, target, &path, limit)
1513 
        })
1514 
        .await?;
1515 
    Ok(crate::web::raw(f.bytes, &f.name, false))
1516 
}
1517
1518 
async fn blame(
1519 
    State(app): State<Shared>,
1520 
    headers: HeaderMap,
1521 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
1522 
) -> Result<Json<Vec<BlameLine>>, ApiError> {
1523 
    let c = caller(&app, &headers).await?;
1524 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1525 
    let limit = app.config.limits.render_limit.0;
1526 
    let b = app
1527 
        .repos
1528 
        .read(&repo, move |repo, cache| {
1529 
            let target = view::resolve(repo, cache, &r)?;
1530 
            view::blame(repo, cache, target, &path, limit)
1531 
        })
1532 
        .await?;
1533 
    Ok(Json(
1534 
        b.lines
1535 
            .into_iter()
1536 
            .map(|l| BlameLine {
1537 
                line: l.line,
1538 
                change: l.hash.to_hex(),
1539 
                index: l.index,
1540 
                author: l.author,
1541 
                when_ms: l.when_ms,
1542 
                text: String::from_utf8_lossy(&l.text).into_owned(),
1543 
            })
1544 
            .collect(),
1545 
    ))
1546 
}
1547
1548 
async fn conflicts(
1549 
    State(app): State<Shared>,
1550 
    headers: HeaderMap,
1551 
    Path((owner, name)): Path<(String, String)>,
1552 
) -> Result<Json<Vec<Conflict>>, ApiError> {
1553 
    let c = caller(&app, &headers).await?;
1554 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1555 
    let list = app.repos.read(&repo, view::conflicts).await?;
1556 
    Ok(Json(
1557 
        list.into_iter()
1558 
            .map(|c| Conflict {
1559 
                bookmark: c.bookmark,
1560 
                path: c.path,
1561 
                kind: c.kind,
1562 
                contributors: c.contributors.iter().map(|x| x.hash.clone()).collect(),
1563 
            })
1564 
            .collect(),
1565 
    ))
df940d75 Andy McCall ↶ 1566 
}
1567
1568 
/// `GET /repos/{o}/{n}/releases/trust/{tag}`: a release's trust report
1569 
/// (hub spec §9.1), as the page's JSON export.
1570 
async fn release_trust(
1571 
    State(app): State<Shared>,
1572 
    headers: HeaderMap,
1573 
    Path((owner, name, tag)): Path<(String, String, String)>,
1574 
) -> Result<Json<crate::web::release_trust::ReleaseTrust>, ApiError> {
1575 
    let c = caller(&app, &headers).await?;
1576 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1577 
    match crate::web::release_trust::report(&app, &repo, &row, &tag).await.map_err(|m| ApiError(StatusCode::INTERNAL_SERVER_ERROR, m))? {
1578 
        Some(t) => Ok(Json(t)),
1579 
        None => Err(ApiError(StatusCode::NOT_FOUND, format!("no release {tag}"))),
1580 
    }
b64e2537 Andy McCall ↶ 1581 
}
1582
1583 
async fn trust(
1584 
    State(app): State<Shared>,
1585 
    headers: HeaderMap,
1586 
    Path((owner, name)): Path<(String, String)>,
1587 
) -> Result<Json<Trust>, ApiError> {
1588 
    let c = caller(&app, &headers).await?;
1589 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1590 
    let key = app.hub_key.key;
1591 
    let t = app.repos.read(&repo, move |r, cache| view::trust(r, cache, &key)).await?;
1592 
    Ok(Json(Trust {
1593 
        policy: t.policy.map(|p| Policy {
1594 
            serial: p.serial,
1595 
            expires_ms: p.expires_ms,
1596 
            roots: p.roots.iter().map(|k| k.key.clone()).collect(),
1597 
            root_threshold: p.root_threshold,
1598 
            rules: p
1599 
                .rules
1600 
                .iter()
1601 
                .map(|r| Rule {
1602 
                    pattern: r.pattern.clone(),
1603 
                    keys: r.keys.iter().map(|k| k.key.clone()).collect(),
1604 
                    threshold: r.threshold,
1605 
                    require: r.require.clone(),
1606 
                    allow_conflicts: r.allow_conflicts,
1607 
                })
1608 
                .collect(),
1609 
        }),
1610 
        signed: t.verification.signed,
1611 
        sealed: t.verification.sealed,
1612 
        unsigned: t.verification.unsigned,
1613 
        invalid: t.verification.invalid.iter().map(|(h, _)| h.clone()).collect(),
1614 
        hub_key: t.hub_key,
1615 
    }))
1616 
}
1617
1618 
async fn pushes(
1619 
    State(app): State<Shared>,
1620 
    headers: HeaderMap,
1621 
    Path((owner, name)): Path<(String, String)>,
1622 
) -> Result<Json<Vec<Push>>, ApiError> {
1623 
    let c = caller(&app, &headers).await?;
1624 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1625 
    let rows = db::repos::pushes(&app.db, row.id, 200).await?;
1626 
    Ok(Json(
1627 
        rows.into_iter()
1628 
            .map(|p| Push {
1629 
                at_ms: p.at_ms,
1630 
                pusher: p.pusher,
1631 
                reference: p.reference,
1632 
                ok: p.ok,
1633 
                reason: p.reason,
1634 
                old_state: p.old_state,
1635 
                new_state: p.new_state,
1636 
                heads: p.heads,
1637 
                changes: p.changes,
1638 
            })
1639 
            .collect(),
1640 
    ))
de505df5 Andy McCall ↶ 1641 
}
1642
b64e2537 Andy McCall ↶ 1643 
// --------------------------------------------------------------- proposals
1644
d7e2c275 Andy McCall ↶ 1645 
/// `GET /repos/{o}/{n}/proposals?state=open|draft|landed|closed|all&limit=N`:
1646 
/// open ones (drafts too) by default, newest first, the first `limit` if
1647 
/// given (#331).
de505df5 Andy McCall ↶ 1648 
async fn proposals(
1649 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 1650 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 1651 
    Path((owner, name)): Path<(String, String)>,
d7e2c275 Andy McCall ↶ 1652 
    Query(q): Query<ProposalsQuery>,
b64e2537 Andy McCall ↶ 1653 
) -> Result<Json<Vec<Proposal>>, ApiError> {
1654 
    let c = caller(&app, &headers).await?;
1655 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
0b20f1ec Andy McCall ↶ 1656 
    let states: &[&str] = match q.state.as_deref().unwrap_or("open") {
1657 
        "open" => &["open", "draft"],
1658 
        "draft" => &["draft"],
1659 
        "landed" => &["landed"],
1660 
        "closed" => &["closed"],
1661 
        "all" => &["open", "draft", "landed", "closed"],
1662 
        other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state is open, draft, landed, closed or all, not {other:?}"))),
1663 
    };
46b5e2c5 Andy McCall ↶ 1664 
    // Each proposal's projected state is worked out from the store, which
1665 
    // for a bucket-backed repository is many slow round trips: four at a
1666 
    // time, in order, each under the repository's read lock only. One at
d7e2c275 Andy McCall ↶ 1667 
    // a time took 28 s for a repository on GCS (oxygenhub#171). A landed
1668 
    // or closed one is as recorded, not projected again (#331).
46b5e2c5 Andy McCall ↶ 1669 
    use futures::StreamExt;
d7e2c275 Andy McCall ↶ 1670 
    let mut rows = db::proposals::list(&app.db, row.id, states).await?;
1671 
    if let Some(limit) = q.limit {
1672 
        rows.truncate(limit);
1673 
    }
46b5e2c5 Andy McCall ↶ 1674 
    let out: Vec<Result<Proposal, ApiError>> = futures::stream::iter(rows)
1675 
        .map(|p| {
1676 
            let (app, repo, owner, name, id) = (app.clone(), repo.clone(), owner.clone(), name.clone(), row.id);
1677 
            async move {
d7e2c275 Andy McCall ↶ 1678 
                let loaded = crate::web::proposals::load_for_api(&app, &repo, p).await?;
46b5e2c5 Andy McCall ↶ 1679 
                let v = crate::web::proposals::verdict(&app, &loaded, id).await?;
1680 
                Ok(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)
1681 
            }
1682 
        })
1683 
        .buffered(4)
1684 
        .collect()
1685 
        .await;
1686 
    Ok(Json(out.into_iter().collect::<Result<Vec<_>, _>>()?))
de505df5 Andy McCall ↶ 1687 
}
1688
1689 
async fn proposal(
1690 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 1691 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 1692 
    Path((owner, name, number)): Path<(String, String, i64)>,
b64e2537 Andy McCall ↶ 1693 
) -> Result<Json<Proposal>, ApiError> {
1694 
    let c = caller(&app, &headers).await?;
1695 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1696 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
de505df5 Andy McCall ↶ 1697 
    let source_url = match p.source_repo_id {
1698 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
1699 
        None => None,
1700 
    };
d7e2c275 Andy McCall ↶ 1701 
    let loaded = crate::web::proposals::load_for_api(&app, &repo, p).await?;
de505df5 Andy McCall ↶ 1702 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1703 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
1f1eb06a Andy McCall ↶ 1704 
}
1705
739a763a Andy McCall ↶ 1706 
/// `PATCH /repos/{o}/{n}/proposals/{number}`: change the title or body,
1707 
/// keeping what is not given; the author or a maintainer, as on the page
1708 
/// (oxygenhub#76). The target is changed on the page, which re-projects.
1709 
async fn edit_proposal(
1710 
    State(app): State<Shared>,
1711 
    headers: HeaderMap,
1712 
    Path((owner, name, number)): Path<(String, String, i64)>,
1713 
    Json(body): Json<hub_api::ProposalEdit>,
1714 
) -> Result<Json<Proposal>, ApiError> {
1715 
    let c = caller(&app, &headers).await?;
1716 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1717 
    let (repo, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1718 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2291f8cc Andy McCall ↶ 1719 
    let text = body.title.is_some() || body.body.is_some();
1720 
    if text && Some(me.id) != p.author_id && role < Role::Maintain {
739a763a Andy McCall ↶ 1721 
        return Err(ApiError(StatusCode::FORBIDDEN, "only the proposal's author or a maintainer can edit it".into()));
2291f8cc Andy McCall ↶ 1722 
    }
1723 
    if body.labels.is_some() && role < Role::Triage {
1724 
        return Err(forbidden("setting labels needs triage access"));
1725 
    }
1726 
    // Every name is checked before anything changes.
1727 
    let labels = resolve_triage(&app, row.id, body.labels.as_deref(), None, None).await?.labels;
1728 
    if text {
1729 
        let title = match body.title.as_deref().map(str::trim) {
1730 
            Some("") => return Err(ApiError(StatusCode::BAD_REQUEST, "a proposal needs a title".into())),
1731 
            Some(t) => t,
1732 
            None => p.title.as_str(),
1733 
        };
1734 
        let text = body.body.as_deref().map(str::trim).unwrap_or(&p.body);
1735 
        db::proposals::edit(&app.db, p.id, title, text, &p.target).await?;
1736 
        db::proposals::add_event(&app.db, p.id, &me.username, "edited", "").await.ok();
739a763a Andy McCall ↶ 1737 
    }
2291f8cc Andy McCall ↶ 1738 
    if let Some(want) = labels {
1739 
        let have = db::issues::proposal_labels(&app.db, p.id).await?;
1740 
        for l in &have {
1741 
            if !want.iter().any(|w| w.id == l.id) {
1742 
                db::issues::set_proposal_label(&app.db, p.id, l.id, false).await?;
1743 
            }
1744 
        }
1745 
        for w in &want {
1746 
            if !have.iter().any(|l| l.id == w.id) {
1747 
                db::issues::set_proposal_label(&app.db, p.id, w.id, true).await?;
1748 
            }
1749 
        }
1750 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
1751 
        db::proposals::add_event(&app.db, p.id, &me.username, "set labels", &names.join(", ")).await.ok();
1752 
    }
09ffa7b6 Andy McCall ↶ 1753 
    // `draft` says the same as `state`, in the words of creation (#313).
1754 
    let want = match (body.state.as_deref(), body.draft) {
1755 
        (Some(s), Some(d)) if (s == "draft") != d => {
1756 
            return Err(ApiError(StatusCode::BAD_REQUEST, format!("state {s:?} and draft {d} disagree")));
1757 
        }
1758 
        (Some(s), _) => Some(s),
1759 
        (None, Some(true)) => Some("draft"),
1760 
        (None, Some(false)) => Some("open"),
1761 
        (None, None) => None,
1762 
    };
1763 
    if let Some(want) = want {
71e65fcf Andy McCall ↶ 1764 
        if Some(me.id) != p.author_id && role < Role::Triage {
1765 
            return Err(ApiError(
1766 
                StatusCode::FORBIDDEN,
09ffa7b6 Andy McCall ↶ 1767 
                "only the proposal's author or someone with triage access can close, reopen or change whether it is a draft".into(),
71e65fcf Andy McCall ↶ 1768 
            ));
1769 
        }
09ffa7b6 Andy McCall ↶ 1770 
        // The page's transitions: a draft is made ready (open), and an open
1771 
        // proposal turned back into a draft.
71e65fcf Andy McCall ↶ 1772 
        let new_state = match (want, p.state.as_str()) {
1773 
            ("closed", "open" | "draft") => "closed",
09ffa7b6 Andy McCall ↶ 1774 
            ("open", "closed" | "draft") => "open",
1775 
            ("draft", "open") => "draft",
71e65fcf Andy McCall ↶ 1776 
            (w, now) if w == now => now,
09ffa7b6 Andy McCall ↶ 1777 
            ("closed" | "open" | "draft", now) => {
71e65fcf Andy McCall ↶ 1778 
                return Err(ApiError(StatusCode::CONFLICT, format!("a proposal that is {now} cannot become {want}")))
1779 
            }
09ffa7b6 Andy McCall ↶ 1780 
            _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is closed, open or draft".into())),
71e65fcf Andy McCall ↶ 1781 
        };
1782 
        if new_state != p.state {
1783 
            db::proposals::set_state(&app.db, p.id, new_state, "").await?;
1784 
            db::proposals::add_event(&app.db, p.id, &me.username, new_state, "").await.ok();
1785 
            crate::hooks::emit(&app, &row, &format!("proposal.{new_state}"), &me.username, serde_json::json!({ "number": number })).await;
1786 
        }
1787 
    }
739a763a Andy McCall ↶ 1788 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1789 
    let source_url = match p.source_repo_id {
1790 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
1791 
        None => None,
1792 
    };
d7e2c275 Andy McCall ↶ 1793 
    let loaded = crate::web::proposals::load_for_api(&app, &repo, p).await?;
739a763a Andy McCall ↶ 1794 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1795 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
1796 
}
1797
1f1eb06a Andy McCall ↶ 1798 
/// `POST /repos/{o}/{n}/proposals/{number}/land` (repo:write): land it as
1799 
/// the page's Land button does; `409` with the blockers when it cannot.
2a8b6216 Andy McCall ↶ 1800 
/// `{"over_checks": "reason"}` lands over required checks that have not
1801 
/// passed, for maintainers (#261).
1f1eb06a Andy McCall ↶ 1802 
async fn land_proposal(
1803 
    State(app): State<Shared>,
1804 
    headers: HeaderMap,
1805 
    Path((owner, name, number)): Path<(String, String, i64)>,
2a8b6216 Andy McCall ↶ 1806 
    body: axum::body::Bytes,
1f1eb06a Andy McCall ↶ 1807 
) -> Result<Json<Proposal>, ApiError> {
1808 
    let c = caller(&app, &headers).await?;
1809 
    let me = c.require("repo:write")?.clone();
2a8b6216 Andy McCall ↶ 1810 
    let over_checks: Option<String> = if body.iter().all(u8::is_ascii_whitespace) {
1811 
        None
1812 
    } else {
1813 
        serde_json::from_slice::<serde_json::Value>(&body)
1814 
            .map_err(|_| ApiError(StatusCode::BAD_REQUEST, "the body is JSON: {} or {\"over_checks\": \"reason\"}".into()))?
1815 
            .get("over_checks")
1816 
            .and_then(|v| v.as_str())
1817 
            .map(String::from)
1818 
    };
1819 
    let need = if over_checks.is_some() { Access::Maintain } else { Access::Write };
1820 
    let (repo, row, _) = reach(&app, &c, &owner, &name, need).await?;
0b20f1ec Andy McCall ↶ 1821 
    let via = format!("api (token {})", c.token);
2a8b6216 Andy McCall ↶ 1822 
    match crate::web::proposals::land_as(&app, &repo, &row, &me, number, &via, false, over_checks.as_deref()).await {
1f1eb06a Andy McCall ↶ 1823 
        Ok(_) => proposal(State(app), headers, Path((owner, name, number))).await,
1824 
        Err(crate::web::proposals::Landing::NotFound) => Err(not_found("no such proposal")),
1825 
        Err(crate::web::proposals::Landing::Refused(m)) => Err(ApiError(StatusCode::CONFLICT, m)),
1826 
    }
d23464c0 Andy McCall ↶ 1827 
}
1828
86a69b53 Andy McCall ↶ 1829 
/// `POST /repos/{o}/{n}/proposals/{number}/auto-land` (repo:write, #261):
1830 
/// land it when its checks pass; at once if they already have.
1831 
async fn auto_land_on(
1832 
    State(app): State<Shared>,
1833 
    headers: HeaderMap,
1834 
    Path((owner, name, number)): Path<(String, String, i64)>,
1835 
) -> Result<Json<Proposal>, ApiError> {
1836 
    auto_land_set(&app, &headers, &owner, &name, number, true).await?;
1837 
    proposal(State(app), headers, Path((owner, name, number))).await
1838 
}
1839
1840 
/// `DELETE …/auto-land`: it will not land by itself.
1841 
async fn auto_land_off(
1842 
    State(app): State<Shared>,
1843 
    headers: HeaderMap,
1844 
    Path((owner, name, number)): Path<(String, String, i64)>,
1845 
) -> Result<Json<Proposal>, ApiError> {
1846 
    auto_land_set(&app, &headers, &owner, &name, number, false).await?;
1847 
    proposal(State(app), headers, Path((owner, name, number))).await
1848 
}
1849
1850 
async fn auto_land_set(app: &Shared, headers: &HeaderMap, owner: &str, name: &str, number: i64, on: bool) -> Result<(), ApiError> {
1851 
    let c = caller(app, headers).await?;
1852 
    let me = c.require("repo:write")?.clone();
1853 
    let (_, row, _) = reach(app, &c, owner, name, Access::Write).await?;
1854 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1855 
    if !p.is_open() {
1856 
        return Err(ApiError(StatusCode::CONFLICT, format!("the proposal is {}", p.state)));
1857 
    }
1858 
    crate::autoland::set(app, &row, &p, &me, on).await?;
1859 
    Ok(())
1860 
}
1861
3f02e5ea Andy McCall ↶ 1862 
/// The files a proposal changes (hub spec §12.1).
1863 
async fn proposal_files(
1864 
    State(app): State<Shared>,
1865 
    headers: HeaderMap,
1866 
    Path((owner, name, number)): Path<(String, String, i64)>,
1867 
) -> Result<Json<Vec<hub_api::ProposalFile>>, ApiError> {
1868 
    let c = caller(&app, &headers).await?;
1869 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1870 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1871 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
1872 
    Ok(Json(
1873 
        loaded
1874 
            .files
1875 
            .iter()
1876 
            .map(|f| hub_api::ProposalFile {
1877 
                path: f.path.clone(),
1878 
                from: f.from.clone(),
1879 
                kind: f.kind.clone(),
1880 
                added: f.added,
1881 
                removed: f.removed,
1882 
            })
1883 
            .collect(),
1884 
    ))
1885 
}
1886
70c3d029 Andy McCall ↶ 1887 
/// `GET …/proposals/{number}/diff`: each file the proposal changes with its
1888 
/// diff (three lines of context, as a change's), as the proposal page shows
1889 
/// them, for clients that draw diffs (oxygenhub-android#4).
1890 
async fn proposal_diff(
1891 
    State(app): State<Shared>,
1892 
    headers: HeaderMap,
1893 
    Path((owner, name, number)): Path<(String, String, i64)>,
1894 
) -> Result<Json<Vec<FileChange>>, ApiError> {
1895 
    let c = caller(&app, &headers).await?;
1896 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1897 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1898 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
1899 
    Ok(Json(loaded.files.into_iter().map(file_change).collect()))
1900 
}
1901
3f02e5ea Andy McCall ↶ 1902 
/// One file's bytes on a side of a proposal: `base` is the target's
1903 
/// state, `head` the projected state. 404 when the file does not exist
1904 
/// on that side.
1905 
async fn proposal_content(
1906 
    State(app): State<Shared>,
1907 
    headers: HeaderMap,
1908 
    Path((owner, name, number, side, path)): Path<(String, String, i64, String, String)>,
1909 
) -> Result<Response, ApiError> {
1910 
    let c = caller(&app, &headers).await?;
1911 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1912 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3571c519 Andy McCall ↶ 1913 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
3f02e5ea Andy McCall ↶ 1914 
    let heads = match side.as_str() {
1915 
        "base" => loaded.target_heads,
1916 
        "head" => loaded.heads,
1917 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "the side is base or head".into())),
1918 
    };
1919 
    let limit = app.config.limits.render_limit.0;
1920 
    let target = view::RefTarget { label: side, kind: view::RefKind::Change, heads };
1921 
    let f = app.repos.read(&repo, move |repo, cache| view::file(repo, cache, target, &path, limit)).await?;
1922 
    Ok(crate::web::raw(f.bytes, &f.name, false))
1923 
}
1924
b64e2537 Andy McCall ↶ 1925 
async fn create_proposal(
1926 
    State(app): State<Shared>,
1927 
    headers: HeaderMap,
1928 
    Path((owner, name)): Path<(String, String)>,
1929 
    Json(body): Json<NewProposal>,
1930 
) -> Result<(StatusCode, Json<Proposal>), ApiError> {
1931 
    let c = caller(&app, &headers).await?;
1932 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1933 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1934 
    let created =
1935 
        crate::web::proposals::open_proposal(&app, &repo, &row, &me, &body.title, &body.body, &body.target, &body.source, body.draft)
1936 
            .await
1937 
            .map_err(|e| ApiError(StatusCode::BAD_REQUEST, e))?;
3571c519 Andy McCall ↶ 1938 
    let loaded = crate::web::proposals::load_summary(&app, &repo, created).await?;
b64e2537 Andy McCall ↶ 1939 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1940 
    Ok((StatusCode::CREATED, Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)))
1941 
}
d23464c0 Andy McCall ↶ 1942
b64e2537 Andy McCall ↶ 1943 
fn comment_of(c: &db::proposals::CommentRow) -> Comment {
1944 
    Comment {
1945 
        id: c.id,
1946 
        author: c.author.clone(),
1947 
        body: c.body.clone(),
1948 
        created_ms: c.created_ms,
1949 
        path: if c.path.is_empty() { None } else { Some(c.path.clone()) },
1950 
        anchor: if c.anchor_change.is_empty() {
1951 
            None
1952 
        } else {
1953 
            Some(Atom { change: c.anchor_change.clone(), index: c.anchor_index as u32 })
1954 
        },
c0fac31d Andy McCall ↶ 1955 
        line: None,
b64e2537 Andy McCall ↶ 1956 
        resolved: c.resolved,
d23464c0 Andy McCall ↶ 1957 
    }
1958 
}
1959
b64e2537 Andy McCall ↶ 1960 
async fn proposal_comments(
1961 
    State(app): State<Shared>,
1962 
    headers: HeaderMap,
1963 
    Path((owner, name, number)): Path<(String, String, i64)>,
1964 
) -> Result<Json<Vec<Comment>>, ApiError> {
1965 
    let c = caller(&app, &headers).await?;
1966 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1967 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
c0fac31d Andy McCall ↶ 1968 
    let mut out: Vec<Comment> = db::proposals::comments(&app.db, p.id).await?.iter().map(comment_of).collect();
1969 
    // Place anchored comments on their line of the projected state.
1970 
    let paths: std::collections::BTreeSet<String> = out.iter().filter(|c| c.anchor.is_some()).filter_map(|c| c.path.clone()).collect();
1971 
    if !paths.is_empty() {
1972 
        let repo = RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?;
3571c519 Andy McCall ↶ 1973 
        let heads = crate::web::proposals::load_summary(&app, &repo, p).await?.heads;
c0fac31d Andy McCall ↶ 1974 
        let lines = app
1975 
            .repos
1976 
            .read(&repo, move |r, _| {
1977 
                let mut at = std::collections::HashMap::new();
1978 
                for path in paths {
1979 
                    // A file the projection removed has no lines to place a comment on.
1980 
                    for l in r.blame_in(&path, &heads).unwrap_or_default() {
1981 
                        at.insert((path.clone(), l.hash.to_hex(), l.index), l.line);
1982 
                    }
1983 
                }
1984 
                Ok(at)
1985 
            })
1986 
            .await?;
1987 
        for c in &mut out {
1988 
            if let (Some(path), Some(a)) = (&c.path, &c.anchor) {
1989 
                c.line = lines.get(&(path.clone(), a.change.clone(), a.index)).copied();
1990 
            }
1991 
        }
1992 
    }
1993 
    Ok(Json(out))
b64e2537 Andy McCall ↶ 1994 
}
1995
1996 
async fn proposal_comment(
1997 
    State(app): State<Shared>,
1998 
    headers: HeaderMap,
1999 
    Path((owner, name, number)): Path<(String, String, i64)>,
2000 
    Json(body): Json<NewComment>,
2001 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
2002 
    let c = caller(&app, &headers).await?;
2003 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
2004 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2005 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2006 
    if body.body.trim().is_empty() {
2007 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
2008 
    }
3f4b0ea6 Andy McCall ↶ 2009 
    let (repo, _) = (RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?, ());
2010 
    let anchor = match (body.path.as_deref().map(|x| x.trim_matches('/')), body.line) {
2011 
        (Some(path), Some(line)) if !path.is_empty() => {
2012 
            let loaded = crate::web::proposals::load(&app, &repo, p.clone()).await?;
2013 
            let (heads, file) = (loaded.heads.clone(), path.to_string());
2014 
            let atom = app
2015 
                .repos
2016 
                .read(&repo, move |r, cache| {
2017 
                    let projected = cache.load(r, &heads)?;
2018 
                    Ok(crate::repos::proposals::atom_at(&projected, &file, line).map(|(h, i)| (h.to_hex(), i)))
2019 
                })
2020 
                .await?
2021 
                .ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, format!("{path}:{line} is not a line of the projected state")))?;
2022 
            Some((path.to_string(), atom))
2023 
        }
2024 
        _ => None,
2025 
    };
2026 
    let row_c = db::proposals::add_comment(
2027 
        &app.db,
2028 
        p.id,
2029 
        Some(me.id),
2030 
        &me.username,
2031 
        body.body.trim(),
2032 
        anchor.as_ref().map(|(path, _)| path.as_str()).unwrap_or(""),
2033 
        anchor.as_ref().map(|(_, (h, i))| (h.as_str(), *i as i64)),
2034 
    )
2035 
    .await?;
b64e2537 Andy McCall ↶ 2036 
    crate::notify::deliver(
2037 
        &app,
2038 
        crate::notify::Event {
2039 
            kind: "proposal.comment",
2040 
            title: format!("{owner}/{name}#{number}: {}", p.title),
2041 
            url: format!("/{owner}/{name}/proposal/{number}"),
2042 
            actor: &me,
2043 
            repo_id: row.id,
2044 
            thread: Some(("proposal", p.id)),
2045 
            mention_text: &body.body,
2046 
            direct: p.author_id.into_iter().collect(),
2047 
        },
2048 
    )
2049 
    .await;
2050 
    crate::hooks::emit(
2051 
        &app,
2052 
        &row,
2053 
        "comment.proposal",
2054 
        &me.username,
2055 
        serde_json::json!({ "number": number, "comment": comment_of(&row_c) }),
2056 
    )
2057 
    .await;
c0fac31d Andy McCall ↶ 2058 
    let mut created = comment_of(&row_c);
2059 
    created.line = created.anchor.as_ref().and(body.line);
2060 
    Ok((StatusCode::CREATED, Json(created)))
b64e2537 Andy McCall ↶ 2061 
}
2062
2063 
async fn proposal_reviews(
2064 
    State(app): State<Shared>,
2065 
    headers: HeaderMap,
2066 
    Path((owner, name, number)): Path<(String, String, i64)>,
2067 
) -> Result<Json<Vec<Review>>, ApiError> {
2068 
    let c = caller(&app, &headers).await?;
2069 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2070 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3571c519 Andy McCall ↶ 2071 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
b64e2537 Andy McCall ↶ 2072 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
2073 
    Ok(Json(
2074 
        v.reviews
2075 
            .into_iter()
2076 
            .map(|r| Review {
2077 
                id: r.row.id,
2078 
                author: r.row.author,
2079 
                verdict: r.row.verdict,
2080 
                body: r.row.body,
2081 
                sealed: r.sealed,
2082 
                created_ms: r.row.created_ms,
7d2eb590 Andy McCall ↶ 2083 
                via: r.row.via,
b64e2537 Andy McCall ↶ 2084 
            })
2085 
            .collect(),
2086 
    ))
2087 
}
2088
2089 
async fn proposal_review(
2090 
    State(app): State<Shared>,
2091 
    headers: HeaderMap,
2092 
    Path((owner, name, number)): Path<(String, String, i64)>,
2093 
    Json(body): Json<NewReview>,
2094 
) -> Result<(StatusCode, Json<Review>), ApiError> {
2095 
    let c = caller(&app, &headers).await?;
2096 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
2097 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2098 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2099 
    if !matches!(body.verdict.as_str(), "comment" | "changes" | "approve") {
2100 
        return Err(ApiError(StatusCode::BAD_REQUEST, "verdict is comment, changes or approve".into()));
2101 
    }
2102 
    if body.verdict == "approve" && Some(me.id) == p.author_id {
2103 
        return Err(forbidden("you cannot approve your own proposal"));
2104 
    }
2105 
    let r = db::proposals::add_review(&app.db, p.id, me.id, &me.username, &body.verdict, body.body.trim()).await?;
2106 
    db::proposals::add_event(&app.db, p.id, &me.username, &format!("review.{}", body.verdict), "").await.ok();
cc1cd197 Andy McCall ↶ 2107 
    crate::web::proposals::reviewed(&app, &row, &p, &me, &body.verdict).await;
b64e2537 Andy McCall ↶ 2108 
    crate::hooks::emit(&app, &row, "review", &me.username, serde_json::json!({ "number": number, "verdict": body.verdict })).await;
2109 
    Ok((
2110 
        StatusCode::CREATED,
7d2eb590 Andy McCall ↶ 2111 
        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 ↶ 2112 
    ))
2113 
}
2114
cc1cd197 Andy McCall ↶ 2115 
/// `POST .../proposals/{number}/reviewers`: ask accounts to review (the
2116 
/// author, or a writer). Answers with everyone asked now.
2117 
async fn request_reviewers(
2118 
    State(app): State<Shared>,
2119 
    headers: HeaderMap,
2120 
    Path((owner, name, number)): Path<(String, String, i64)>,
2121 
    Json(body): Json<ReviewRequest>,
2122 
) -> Result<Json<Vec<String>>, ApiError> {
2123 
    let c = caller(&app, &headers).await?;
2124 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
2125 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2126 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2127 
    if Some(me.id) != p.author_id && role < Role::Write {
2128 
        return Err(forbidden("only the author or a writer asks for reviews"));
2129 
    }
2130 
    if !p.is_open() {
2131 
        return Err(ApiError(StatusCode::CONFLICT, "the proposal is not open".into()));
2132 
    }
2133 
    crate::web::proposals::request_reviewers(&app, &row, &p, &me, &body.reviewers)
2134 
        .await
2135 
        .map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2136 
    Ok(Json(db::proposals::review_requests(&app.db, p.id).await?))
2137 
}
2138
2139 
/// `DELETE .../proposals/{number}/reviewers/{username}`: withdraw a request.
2140 
async fn withdraw_reviewer(
2141 
    State(app): State<Shared>,
2142 
    headers: HeaderMap,
2143 
    Path((owner, name, number, username)): Path<(String, String, i64, String)>,
2144 
) -> Result<StatusCode, ApiError> {
2145 
    let c = caller(&app, &headers).await?;
2146 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
2147 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2148 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2149 
    if Some(me.id) != p.author_id && role < Role::Write {
2150 
        return Err(forbidden("only the author or a writer withdraws review requests"));
2151 
    }
2152 
    let a = db::accounts::account_by_name(&app.db, &username).await?.ok_or_else(|| not_found("no such account"))?;
2153 
    if db::proposals::unrequest_review(&app.db, p.id, a.id).await? {
2154 
        db::proposals::add_event(&app.db, p.id, &me.username, "review request withdrawn", &a.username).await.ok();
2155 
    }
2156 
    Ok(StatusCode::NO_CONTENT)
2157 
}
2158
b64e2537 Andy McCall ↶ 2159 
async fn proposal_checks(
2160 
    State(app): State<Shared>,
2161 
    headers: HeaderMap,
2162 
    Path((owner, name, number)): Path<(String, String, i64)>,
2163 
) -> Result<Json<Vec<Check>>, ApiError> {
2164 
    let c = caller(&app, &headers).await?;
2165 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2166 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3571c519 Andy McCall ↶ 2167 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
b64e2537 Andy McCall ↶ 2168 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await?.iter().map(check_of).collect()))
2169 
}
2170
2171 
// ------------------------------------------------------------------ issues
2172
2173 
async fn issue_of(app: &Shared, row: &db::repos::RepoRow, i: &db::issues::IssueRow) -> Result<Issue, ApiError> {
2174 
    let labels = db::issues::issue_labels(&app.db, i.id)
2175 
        .await?
2176 
        .into_iter()
2177 
        .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
2178 
        .collect();
2179 
    let assignees = db::issues::assignees(&app.db, i.id).await?;
2180 
    let milestone = match i.milestone_id {
2181 
        Some(id) => db::issues::milestone(&app.db, id).await?.map(|m| m.title),
2182 
        None => None,
2183 
    };
5d90e0e0 Andy McCall 2184 
    let comments: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM issue_comments WHERE issue_id = $1").bind(i.id).fetch_one(&app.db).await?;
b64e2537 Andy McCall ↶ 2185 
    Ok(Issue {
2186 
        number: i.number,
2187 
        title: i.title.clone(),
2188 
        body: i.body.clone(),
2189 
        author: i.author.clone(),
2190 
        state: i.state.clone(),
2191 
        reason: i.reason.clone(),
2192 
        labels,
2193 
        assignees,
2194 
        milestone,
2195 
        comments,
2196 
        locked: i.locked,
2197 
        pinned: i.pinned,
2198 
        created_ms: i.created_ms,
2199 
        updated_ms: i.updated_ms,
2200 
        closed_ms: i.closed_ms,
2201 
        url: format!("{}/{}/issue/{}", app.config.base_url(), row.slug(), i.number),
2202 
    })
2203 
}
2204
2205 
#[derive(Deserialize)]
2206 
struct IssuesQuery {
2207 
    state: Option<String>,
d7e2c275 Andy McCall ↶ 2208 
}
2209
2210 
#[derive(Deserialize)]
2211 
struct ProposalsQuery {
2212 
    state: Option<String>,
2213 
    limit: Option<usize>,
b64e2537 Andy McCall ↶ 2214 
}
2215
2216 
async fn issues(
2217 
    State(app): State<Shared>,
2218 
    headers: HeaderMap,
2219 
    Path((owner, name)): Path<(String, String)>,
2220 
    Query(q): Query<IssuesQuery>,
2221 
) -> Result<Json<Vec<Issue>>, ApiError> {
2222 
    let c = caller(&app, &headers).await?;
2223 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2224 
    let state = q.state.unwrap_or_else(|| "open".into());
2225 
    let mut out = Vec::new();
2226 
    for i in db::issues::list(&app.db, row.id).await? {
2227 
        if state == "all" || i.state == state {
2228 
            out.push(issue_of(&app, &row, &i).await?);
d23464c0 Andy McCall ↶ 2229 
        }
2230 
    }
b64e2537 Andy McCall ↶ 2231 
    Ok(Json(out))
d23464c0 Andy McCall ↶ 2232 
}
2233
b64e2537 Andy McCall ↶ 2234 
async fn create_issue(
2235 
    State(app): State<Shared>,
2236 
    headers: HeaderMap,
2237 
    Path((owner, name)): Path<(String, String)>,
2238 
    Json(body): Json<NewIssue>,
2239 
) -> Result<(StatusCode, Json<Issue>), ApiError> {
2240 
    let c = caller(&app, &headers).await?;
2241 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
76f262e1 Andy McCall ↶ 2242 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
b64e2537 Andy McCall ↶ 2243 
    if body.title.trim().is_empty() {
2244 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
d23464c0 Andy McCall ↶ 2245 
    }
76f262e1 Andy McCall ↶ 2246 
    let triage = !body.labels.is_empty() || !body.assignees.is_empty() || body.milestone.is_some();
2247 
    if triage && role < Role::Triage {
2248 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
2249 
    }
2250 
    // Check the names before anything is created.
2251 
    resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
b64e2537 Andy McCall ↶ 2252 
    let i = db::issues::create(
2253 
        &app.db,
2254 
        db::issues::NewIssue {
2255 
            repo_id: row.id,
2256 
            title: body.title.trim(),
2257 
            body: body.body.trim(),
2258 
            author_id: Some(me.id),
2259 
            author: &me.username,
2260 
        },
2261 
    )
2262 
    .await?;
2263 
    db::issues::add_event(&app.db, i.id, &me.username, "opened", "").await.ok();
76f262e1 Andy McCall ↶ 2264 
    if triage {
2265 
        let t = resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
2266 
        apply_triage(&app, &i, &me, t).await?;
2267 
    }
2268 
    let i = db::issues::get(&app.db, row.id, i.number).await?.unwrap_or(i);
b64e2537 Andy McCall ↶ 2269 
    crate::web::issues::reindex(&app, row.id, &i).await;
2270 
    let api = issue_of(&app, &row, &i).await?;
2271 
    crate::notify::deliver(
2272 
        &app,
2273 
        crate::notify::Event {
2274 
            kind: "issue.opened",
2275 
            title: format!("{owner}/{name}#{}: {}", i.number, i.title),
2276 
            url: format!("/{owner}/{name}/issue/{}", i.number),
2277 
            actor: &me,
2278 
            repo_id: row.id,
2279 
            thread: Some(("issue", i.id)),
2280 
            mention_text: &body.body,
2281 
            direct: vec![],
2282 
        },
2283 
    )
2284 
    .await;
2285 
    crate::hooks::emit(&app, &row, "issue.opened", &me.username, serde_json::json!({ "issue": api })).await;
2286 
    Ok((StatusCode::CREATED, Json(api)))
2287 
}
2288
2289 
async fn issue(
2290 
    State(app): State<Shared>,
2291 
    headers: HeaderMap,
2292 
    Path((owner, name, number)): Path<(String, String, i64)>,
2293 
) -> Result<Json<Issue>, ApiError> {
2294 
    let c = caller(&app, &headers).await?;
2295 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2296 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
2297 
    Ok(Json(issue_of(&app, &row, &i).await?))
2298 
}
2299
2300 
async fn issue_state(
2301 
    State(app): State<Shared>,
2302 
    headers: HeaderMap,
2303 
    Path((owner, name, number)): Path<(String, String, i64)>,
2304 
    Json(body): Json<IssueStateChange>,
2305 
) -> Result<Json<Issue>, ApiError> {
2306 
    let c = caller(&app, &headers).await?;
2307 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
2308 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2309 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
2310 
    if role < Role::Triage && Some(me.id) != i.author_id {
2311 
        return Err(forbidden("only the author or triage may change the state"));
2312 
    }
2313 
    let (state, reason) = match body.state.as_str() {
2314 
        "closed" => ("closed", if body.reason == "not_planned" { "not_planned" } else { "completed" }),
2315 
        "open" => ("open", ""),
2316 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is open or closed".into())),
2317 
    };
2318 
    db::issues::set_state(&app.db, i.id, state, reason).await?;
2319 
    db::issues::add_event(&app.db, i.id, &me.username, if state == "closed" { "closed" } else { "reopened" }, "").await.ok();
2320 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
2321 
    let api = issue_of(&app, &row, &fresh).await?;
2322 
    crate::hooks::emit(
2323 
        &app,
2324 
        &row,
2325 
        if state == "closed" { "issue.closed" } else { "issue.reopened" },
2326 
        &me.username,
2327 
        serde_json::json!({ "issue": api }),
2328 
    )
2329 
    .await;
2330 
    Ok(Json(api))
2331 
}
2332
2333 
async fn issue_comments(
2334 
    State(app): State<Shared>,
2335 
    headers: HeaderMap,
2336 
    Path((owner, name, number)): Path<(String, String, i64)>,
2337 
) -> Result<Json<Vec<Comment>>, ApiError> {
2338 
    let c = caller(&app, &headers).await?;
2339 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2340 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
2341 
    Ok(Json(
2342 
        db::issues::comments(&app.db, i.id)
2343 
            .await?
2344 
            .into_iter()
2345 
            .map(|c| Comment {
2346 
                id: c.id,
2347 
                author: c.author,
2348 
                body: c.body,
2349 
                created_ms: c.created_ms,
2350 
                path: None,
2351 
                anchor: None,
c0fac31d Andy McCall ↶ 2352 
                line: None,
b64e2537 Andy McCall ↶ 2353 
                resolved: false,
2354 
            })
2355 
            .collect(),
2356 
    ))
2357 
}
2358
2359 
async fn issue_comment(
2360 
    State(app): State<Shared>,
2361 
    headers: HeaderMap,
2362 
    Path((owner, name, number)): Path<(String, String, i64)>,
2363 
    Json(body): Json<NewComment>,
2364 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
2365 
    let c = caller(&app, &headers).await?;
2366 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
2367 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2368 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
2369 
    if i.locked && role < Role::Triage {
2370 
        return Err(forbidden("this issue is locked"));
2371 
    }
2372 
    if body.body.trim().is_empty() {
2373 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
2374 
    }
2375 
    let cm = db::issues::add_comment(&app.db, i.id, Some(me.id), &me.username, body.body.trim()).await?;
2376 
    crate::web::issues::reindex(&app, row.id, &i).await;
2377 
    crate::notify::deliver(
2378 
        &app,
2379 
        crate::notify::Event {
2380 
            kind: "issue.comment",
2381 
            title: format!("{owner}/{name}#{number}: {}", i.title),
2382 
            url: format!("/{owner}/{name}/issue/{number}"),
2383 
            actor: &me,
2384 
            repo_id: row.id,
2385 
            thread: Some(("issue", i.id)),
2386 
            mention_text: &body.body,
2387 
            direct: i.author_id.into_iter().collect(),
2388 
        },
2389 
    )
2390 
    .await;
c0fac31d Andy McCall ↶ 2391 
    let api = Comment {
2392 
        id: cm.id,
2393 
        author: cm.author,
2394 
        body: cm.body,
2395 
        created_ms: cm.created_ms,
2396 
        path: None,
2397 
        anchor: None,
2398 
        line: None,
2399 
        resolved: false,
2400 
    };
b64e2537 Andy McCall ↶ 2401 
    crate::hooks::emit(&app, &row, "comment.issue", &me.username, serde_json::json!({ "number": number, "comment": api })).await;
2402 
    Ok((StatusCode::CREATED, Json(api)))
76f262e1 Andy McCall ↶ 2403 
}
2404
2405 
/// Labels, assignees and milestone named in a request, looked up.
2406 
struct Triage {
2407 
    labels: Option<Vec<db::issues::Label>>,
2408 
    assignees: Option<Vec<Account>>,
2409 
    /// `Some(None)` clears the milestone.
2410 
    milestone: Option<Option<db::issues::Milestone>>,
2411 
}
2412
2413 
async fn resolve_triage(
2414 
    app: &Shared,
2415 
    repo_id: i64,
2416 
    labels: Option<&[String]>,
2417 
    assignees: Option<&[String]>,
2418 
    milestone: Option<&str>,
2419 
) -> Result<Triage, ApiError> {
2420 
    let bad = |m: String| ApiError(StatusCode::BAD_REQUEST, m);
2421 
    let labels = match labels {
2422 
        Some(names) => {
2423 
            let mut out = Vec::new();
2424 
            for n in names {
2425 
                out.push(
2426 
                    db::issues::label_by_name(&app.db, repo_id, n.trim())
2427 
                        .await?
2428 
                        .ok_or_else(|| bad(format!("no label {n:?}; create it first")))?,
2429 
                );
2430 
            }
2431 
            Some(out)
2432 
        }
2433 
        None => None,
2434 
    };
2435 
    let assignees = match assignees {
2436 
        Some(names) => {
2437 
            let mut out = Vec::new();
2438 
            for n in names {
2439 
                out.push(db::accounts::account_by_name(&app.db, n.trim()).await?.ok_or_else(|| bad(format!("no account {n:?}")))?);
2440 
            }
2441 
            Some(out)
2442 
        }
2443 
        None => None,
2444 
    };
2445 
    let milestone = match milestone.map(str::trim) {
2446 
        None => None,
2447 
        Some("") => Some(None),
2448 
        Some(title) => Some(Some(
2449 
            db::issues::milestones(&app.db, repo_id)
2450 
                .await?
2451 
                .into_iter()
2452 
                .find(|m| m.title == title)
2453 
                .ok_or_else(|| bad(format!("no milestone {title:?}")))?,
2454 
        )),
2455 
    };
2456 
    Ok(Triage { labels, assignees, milestone })
2457 
}
2458
2459 
/// Make an issue's labels, assignees and milestone what `t` says, with
2460 
/// timeline events for what changed.
2461 
async fn apply_triage(app: &Shared, i: &db::issues::IssueRow, me: &Account, t: Triage) -> Result<(), ApiError> {
2462 
    if let Some(want) = t.labels {
2463 
        let have = db::issues::issue_labels(&app.db, i.id).await?;
2464 
        for l in &have {
2465 
            if !want.iter().any(|w| w.id == l.id) {
2466 
                db::issues::set_issue_label(&app.db, i.id, l.id, false).await?;
2467 
            }
2468 
        }
2469 
        for w in &want {
2470 
            if !have.iter().any(|l| l.id == w.id) {
2471 
                db::issues::set_issue_label(&app.db, i.id, w.id, true).await?;
2472 
            }
2473 
        }
2474 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
2475 
        db::issues::add_event(&app.db, i.id, &me.username, "set labels", &names.join(", ")).await.ok();
2476 
    }
2477 
    if let Some(want) = t.assignees {
2478 
        let have = db::issues::assignees(&app.db, i.id).await?;
2479 
        for name in &have {
2480 
            if !want.iter().any(|a| &a.username == name) {
2481 
                if let Some(a) = db::accounts::account_by_name(&app.db, name).await? {
2482 
                    db::issues::set_assignee(&app.db, i.id, a.id, false).await?;
2483 
                    db::issues::add_event(&app.db, i.id, &me.username, "unassigned", name).await.ok();
2484 
                }
2485 
            }
2486 
        }
2487 
        for a in &want {
2488 
            if !have.contains(&a.username) {
2489 
                db::issues::set_assignee(&app.db, i.id, a.id, true).await?;
2490 
                db::issues::add_event(&app.db, i.id, &me.username, "assigned", &a.username).await.ok();
2491 
            }
2492 
        }
2493 
    }
2494 
    if let Some(m) = t.milestone {
2495 
        db::issues::set_milestone(&app.db, i.id, m.as_ref().map(|m| m.id)).await?;
2496 
        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();
2497 
    }
2498 
    Ok(())
2499 
}
2500
2501 
/// `PATCH /repos/{o}/{n}/issues/{number}`.
2502 
async fn issue_edit(
2503 
    State(app): State<Shared>,
2504 
    headers: HeaderMap,
2505 
    Path((owner, name, number)): Path<(String, String, i64)>,
2506 
    Json(body): Json<IssueEdit>,
2507 
) -> Result<Json<Issue>, ApiError> {
2508 
    let c = caller(&app, &headers).await?;
2509 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
2510 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2511 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
2512 
    let text = body.title.is_some() || body.body.is_some();
2513 
    let triage = body.labels.is_some() || body.assignees.is_some() || body.milestone.is_some();
2514 
    if text && role < Role::Triage && Some(me.id) != i.author_id {
2515 
        return Err(forbidden("only the author or triage may edit the title and body"));
2516 
    }
2517 
    if triage && role < Role::Triage {
2518 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
2519 
    }
2520 
    if i.locked && role < Role::Triage {
2521 
        return Err(forbidden("this issue is locked"));
2522 
    }
2523 
    let t = resolve_triage(&app, row.id, body.labels.as_deref(), body.assignees.as_deref(), body.milestone.as_deref()).await?;
2524 
    if text {
2525 
        let title = body.title.as_deref().map(str::trim).unwrap_or(&i.title);
2526 
        if title.is_empty() {
2527 
            return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
2528 
        }
2529 
        db::issues::edit(&app.db, i.id, title, body.body.as_deref().unwrap_or(&i.body)).await?;
2530 
        db::issues::add_event(&app.db, i.id, &me.username, "edited", "").await.ok();
2531 
    }
2532 
    apply_triage(&app, &i, &me, t).await?;
2533 
    db::issues::touch(&app.db, i.id).await.ok();
2534 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
2535 
    crate::web::issues::reindex(&app, row.id, &fresh).await;
2536 
    let api = issue_of(&app, &row, &fresh).await?;
2537 
    crate::hooks::emit(&app, &row, "issue.edited", &me.username, serde_json::json!({ "issue": api })).await;
2538 
    Ok(Json(api))
2539 
}
2540
2541 
/// `POST /repos/{o}/{n}/labels` (triage).
2542 
async fn create_label(
2543 
    State(app): State<Shared>,
2544 
    headers: HeaderMap,
2545 
    Path((owner, name)): Path<(String, String)>,
2546 
    Json(body): Json<NewLabel>,
2547 
) -> Result<(StatusCode, Json<Label>), ApiError> {
2548 
    let c = caller(&app, &headers).await?;
2549 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
2550 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2551 
    if role < Role::Triage {
2552 
        return Err(forbidden("labels need triage access"));
2553 
    }
2554 
    let label = body.name.trim();
2555 
    if label.is_empty() || label.len() > 50 {
2556 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a label has a name of 1 to 50 characters".into()));
2557 
    }
2558 
    let colour = match body.colour.as_deref() {
2559 
        Some(c) if c.len() == 7 && c.starts_with('#') && c[1..].chars().all(|x| x.is_ascii_hexdigit()) => c.to_string(),
2560 
        Some(c) => return Err(ApiError(StatusCode::BAD_REQUEST, format!("colour {c:?} is not #rrggbb"))),
2561 
        None => "#5aa8ff".to_string(),
2562 
    };
2563 
    let l = db::issues::upsert_label(&app.db, row.id, label, &colour, body.description.trim()).await?;
2564 
    Ok((StatusCode::CREATED, Json(Label { name: l.name, colour: l.colour, description: l.description })))
2565 
}
2566
2567 
/// `DELETE /repos/{o}/{n}/labels/{label}` (triage).
2568 
async fn delete_label(
2569 
    State(app): State<Shared>,
2570 
    headers: HeaderMap,
2571 
    Path((owner, name, label)): Path<(String, String, String)>,
2572 
) -> Result<StatusCode, ApiError> {
2573 
    let c = caller(&app, &headers).await?;
2574 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
2575 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2576 
    if role < Role::Triage {
2577 
        return Err(forbidden("labels need triage access"));
2578 
    }
2579 
    let l = db::issues::label_by_name(&app.db, row.id, &label).await?.ok_or_else(|| not_found("no such label"))?;
2580 
    db::issues::delete_label(&app.db, l.id).await?;
2581 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 2582 
}
2583
b64e2537 Andy McCall ↶ 2584 
async fn labels(
2585 
    State(app): State<Shared>,
2586 
    headers: HeaderMap,
2587 
    Path((owner, name)): Path<(String, String)>,
2588 
) -> Result<Json<Vec<Label>>, ApiError> {
2589 
    let c = caller(&app, &headers).await?;
2590 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2591 
    Ok(Json(
2592 
        db::issues::labels(&app.db, row.id)
2593 
            .await?
2594 
            .into_iter()
2595 
            .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
2596 
            .collect(),
2597 
    ))
2598 
}
2599
2600 
async fn milestones(
2601 
    State(app): State<Shared>,
2602 
    headers: HeaderMap,
2603 
    Path((owner, name)): Path<(String, String)>,
2604 
) -> Result<Json<Vec<Milestone>>, ApiError> {
2605 
    let c = caller(&app, &headers).await?;
2606 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2607 
    let mut out = Vec::new();
2608 
    for m in db::issues::milestones(&app.db, row.id).await? {
2609 
        let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
2610 
        out.push(Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed });
d23464c0 Andy McCall ↶ 2611 
    }
b64e2537 Andy McCall ↶ 2612 
    Ok(Json(out))
2613 
}
2614
5ea4872f Andy McCall ↶ 2615 
fn milestone_of(m: db::issues::Milestone, open: i64, closed: i64) -> Milestone {
2616 
    Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed }
2617 
}
2618
2619 
/// A due date as `YYYY-MM-DD` (UTC midnight), or the empty string for none.
2620 
fn due_ms_of(due: &str) -> Result<Option<i64>, ApiError> {
2621 
    let due = due.trim();
2622 
    if due.is_empty() {
2623 
        return Ok(None);
2624 
    }
2625 
    time::Date::parse(due, &time::macros::format_description!("[year]-[month]-[day]"))
2626 
        .map(|d| Some(d.midnight().assume_utc().unix_timestamp() * 1000))
2627 
        .map_err(|_| ApiError(StatusCode::BAD_REQUEST, format!("due {due:?} is not YYYY-MM-DD")))
2628 
}
2629
2630 
async fn triage_for_milestones(app: &Shared, headers: &HeaderMap, owner: &str, name: &str) -> Result<db::repos::RepoRow, ApiError> {
2631 
    let c = caller(app, headers).await?;
2632 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
2633 
    let (_, row, role) = reach(app, &c, owner, name, Access::Read).await?;
2634 
    if role < Role::Triage {
2635 
        return Err(forbidden("milestones need triage access"));
2636 
    }
2637 
    Ok(row)
2638 
}
2639
2640 
/// `POST /repos/{o}/{n}/milestones` (triage, oxygenhub#91): create a
2641 
/// milestone, or change the description and due date of the one with
2642 
/// that title.
2643 
async fn create_milestone(
2644 
    State(app): State<Shared>,
2645 
    headers: HeaderMap,
2646 
    Path((owner, name)): Path<(String, String)>,
2647 
    Json(body): Json<NewMilestone>,
2648 
) -> Result<(StatusCode, Json<Milestone>), ApiError> {
2649 
    let row = triage_for_milestones(&app, &headers, &owner, &name).await?;
2650 
    let title = body.title.trim();
2651 
    if title.is_empty() || title.len() > 100 {
2652 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a milestone has a title of 1 to 100 characters".into()));
2653 
    }
2654 
    let due_ms = due_ms_of(body.due.as_deref().unwrap_or(""))?;
2655 
    let m = db::issues::upsert_milestone(&app.db, row.id, title, body.description.trim(), due_ms).await?;
2656 
    let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
2657 
    Ok((StatusCode::CREATED, Json(milestone_of(m, open, closed))))
2658 
}
2659
2660 
/// `PATCH /repos/{o}/{n}/milestones/{title}` (triage): title,
2661 
/// description, due date and state; what is not given stays.
2662 
async fn edit_milestone(
2663 
    State(app): State<Shared>,
2664 
    headers: HeaderMap,
2665 
    Path((owner, name, title)): Path<(String, String, String)>,
2666 
    Json(body): Json<MilestoneEdit>,
2667 
) -> Result<Json<Milestone>, ApiError> {
2668 
    let row = triage_for_milestones(&app, &headers, &owner, &name).await?;
2669 
    let m = db::issues::milestones(&app.db, row.id)
2670 
        .await?
2671 
        .into_iter()
2672 
        .find(|m| m.title == title)
2673 
        .ok_or_else(|| not_found("no such milestone"))?;
2674 
    let new_title = body.title.as_deref().map(str::trim).unwrap_or(&m.title);
2675 
    if new_title.is_empty() || new_title.len() > 100 {
2676 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a milestone has a title of 1 to 100 characters".into()));
2677 
    }
2678 
    let due_ms = match body.due.as_deref() {
2679 
        Some(d) => due_ms_of(d)?,
2680 
        None => m.due_ms,
2681 
    };
2682 
    let description = body.description.as_deref().map(str::trim).unwrap_or(&m.description);
2683 
    if body.title.is_some() || body.description.is_some() || body.due.is_some() {
2684 
        db::issues::update_milestone(&app.db, m.id, new_title, description, due_ms).await?;
2685 
    }
2686 
    if let Some(state) = body.state.as_deref() {
2687 
        match state {
2688 
            "open" | "closed" => db::issues::set_milestone_state(&app.db, m.id, state).await?,
2689 
            other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state {other:?} is open or closed"))),
2690 
        }
2691 
    }
2692 
    let fresh = db::issues::milestone(&app.db, m.id).await?.ok_or_else(|| not_found("no such milestone"))?;
2693 
    let (open, closed) = db::issues::milestone_counts(&app.db, fresh.id).await?;
2694 
    Ok(Json(milestone_of(fresh, open, closed)))
2695 
}
2696
b64e2537 Andy McCall ↶ 2697 
// --------------------------------------------------------- hooks, checks
2698
2699 
fn hook_of(h: &db::hooks::Hook) -> Hook {
2700 
    Hook { id: h.id, url: h.url.clone(), events: h.events.clone(), active: h.active, created_ms: h.created_ms }
2701 
}
2702
2703 
async fn hooks(
2704 
    State(app): State<Shared>,
2705 
    headers: HeaderMap,
2706 
    Path((owner, name)): Path<(String, String)>,
2707 
) -> Result<Json<Vec<Hook>>, ApiError> {
2708 
    let c = caller(&app, &headers).await?;
2709 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
2710 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2711 
    Ok(Json(db::hooks::hooks_for_repo(&app.db, row.id).await?.iter().map(hook_of).collect()))
d23464c0 Andy McCall ↶ 2712 
}
2713
b64e2537 Andy McCall ↶ 2714 
async fn create_hook(
2715 
    State(app): State<Shared>,
2716 
    headers: HeaderMap,
2717 
    Path((owner, name)): Path<(String, String)>,
2718 
    Json(body): Json<NewHook>,
2719 
) -> Result<(StatusCode, Json<Hook>), ApiError> {
2720 
    let c = caller(&app, &headers).await?;
2721 
    let me = c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?.clone();
2722 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2723 
    if !(body.url.starts_with("http://") || body.url.starts_with("https://")) {
2724 
        return Err(ApiError(StatusCode::BAD_REQUEST, "the URL must be http or https".into()));
2725 
    }
2726 
    let h = db::hooks::create_hook(&app.db, Some(row.id), None, &body.url, &body.secret, &body.events).await?;
2727 
    db::accounts::audit(&app.db, Some(&me), "hook.created", &row.slug(), &body.url).await.ok();
2728 
    Ok((StatusCode::CREATED, Json(hook_of(&h))))
d23464c0 Andy McCall ↶ 2729 
}
2730
b64e2537 Andy McCall ↶ 2731 
async fn delete_hook(
2732 
    State(app): State<Shared>,
2733 
    headers: HeaderMap,
2734 
    Path((owner, name, id)): Path<(String, String, i64)>,
2735 
) -> Result<StatusCode, ApiError> {
2736 
    let c = caller(&app, &headers).await?;
2737 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
2738 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2739 
    if db::hooks::hook(&app.db, id).await?.is_some_and(|h| h.repo_id == Some(row.id)) {
2740 
        db::hooks::delete_hook(&app.db, id).await?;
2741 
    }
2742 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 2743 
}
2744
b64e2537 Andy McCall ↶ 2745 
pub fn check_of(c: &db::hooks::Check) -> Check {
2746 
    Check {
2747 
        state: c.state.clone(),
2748 
        name: c.name.clone(),
2749 
        status: CheckStatus::parse(&c.status).unwrap_or(CheckStatus::Queued),
2750 
        summary: c.summary.clone(),
2751 
        url: c.url.clone(),
2752 
        reporter: c.reporter.clone(),
2753 
        seal: if c.seal.is_empty() { None } else { Some(c.seal.clone()) },
2754 
        started_ms: c.started_ms,
2755 
        finished_ms: c.finished_ms,
2756 
    }
961c10be Andy McCall ↶ 2757 
}
2758
2759 
/// `GET /repos/{o}/{n}/checks/required`.
2760 
async fn required_checks(
2761 
    State(app): State<Shared>,
2762 
    headers: HeaderMap,
2763 
    Path((owner, name)): Path<(String, String)>,
2764 
) -> Result<Json<RequiredChecks>, ApiError> {
2765 
    let c = caller(&app, &headers).await?;
2766 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2767 
    Ok(Json(RequiredChecks { names: db::hooks::required_checks(&app.db, row.id).await? }))
2768 
}
2769
2770 
/// `PUT /repos/{o}/{n}/checks/required` (repository admin): the whole list.
2771 
async fn set_required_checks(
2772 
    State(app): State<Shared>,
2773 
    headers: HeaderMap,
2774 
    Path((owner, name)): Path<(String, String)>,
2775 
    Json(body): Json<RequiredChecks>,
2776 
) -> Result<Json<RequiredChecks>, ApiError> {
2777 
    let c = caller(&app, &headers).await?;
2778 
    c.require("repo:admin")?;
2779 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2780 
    let mut names: Vec<String> = body.names.iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()).collect();
2781 
    names.sort();
2782 
    names.dedup();
2783 
    if names.len() > 32 || names.iter().any(|n| n.len() > 100 || n.contains(',')) {
2784 
        return Err(ApiError(StatusCode::BAD_REQUEST, "at most 32 check names, each under 100 characters and without commas".into()));
2785 
    }
2786 
    db::hooks::set_required_checks(&app.db, row.id, &names).await?;
2787 
    db::accounts::audit(&app.db, c.account.as_ref(), "repo.required_checks", &format!("{owner}/{name}"), &names.join(", ")).await.ok();
2788 
    Ok(Json(RequiredChecks { names }))
1edac4b6 Andy McCall ↶ 2789 
}
2790
bf3d0754 Andy McCall ↶ 2791 
fn flow_run_of(
2792 
    app: &Shared,
2793 
    row: &db::repos::RepoRow,
2794 
    r: &db::flow::Run,
2795 
    jobs: Vec<db::flow::Job>,
2796 
    queue: &[db::flow::QueueEntry],
2797 
) -> FlowRun {
90326c96 Andy McCall ↶ 2798 
    FlowRun {
bf3d0754 Andy McCall ↶ 2799 
        queue_position: crate::flow::queue_info(queue, row.id, r.id).position.map(|p| p as i64),
90326c96 Andy McCall ↶ 2800 
        number: r.number,
2801 
        bookmark: r.bookmark.clone(),
2802 
        state: r.state.clone(),
2803 
        heads: r.head_list().into_iter().map(String::from).collect(),
2804 
        status: r.status.clone(),
c889911b Andy McCall ↶ 2805 
        trigger: r.trigger_label(),
90326c96 Andy McCall ↶ 2806 
        actor: r.actor.clone(),
2807 
        pipeline_hash: r.pipeline_hash.clone(),
2808 
        error: r.error.clone(),
2809 
        created_ms: r.created_ms,
2810 
        finished_ms: r.finished_ms,
2811 
        url: format!("{}/{}/{}/flow/{}", app.config.base_url(), row.owner, row.name, r.number),
2812 
        jobs: jobs
2813 
            .into_iter()
2814 
            .map(|j| FlowJob {
fac6853c Andy McCall ↶ 2815 
                phases: j.phase_list().into_iter().map(|(name, ms)| hub_api::FlowPhase { name, ms }).collect(),
2816 
                queued_ms: j.queued_ms,
2817 
                ready_ms: j.ready_ms,
2818 
                peak_disk_mib: j.peak_disk_mib,
2819 
                peak_memory_mib: j.peak_memory_mib,
90326c96 Andy McCall ↶ 2820 
                depends_on: j.depends_on(),
2821 
                name: j.name,
2822 
                status: j.status,
2823 
                runner: j.runner,
2824 
                exit_code: j.exit_code,
2825 
                error: j.error,
2826 
                started_ms: j.started_ms,
2827 
                finished_ms: j.finished_ms,
2828 
                log_lines: j.log_count,
4d2e44d7 Andy McCall ↶ 2829 
                waiting: j.waiting,
501d8b26 Andy McCall ↶ 2830 
                placed: j.placed,
b1860d60 Andy McCall ↶ 2831 
                approval: j.approval,
90326c96 Andy McCall ↶ 2832 
            })
2833 
            .collect(),
2834 
    }
2835 
}
2836
1edac4b6 Andy McCall ↶ 2837 
#[derive(Deserialize)]
90326c96 Andy McCall ↶ 2838 
struct RunsPage {
2839 
    /// Runs numbered below this one (the next page).
2840 
    before: Option<i64>,
2841 
    limit: Option<i64>,
2842 
}
2843
2844 
/// `GET /repos/{o}/{n}/flow/runs`: newest first, `?before=N&limit=` (max 100).
2845 
async fn flow_runs(
2846 
    State(app): State<Shared>,
2847 
    headers: HeaderMap,
2848 
    Path((owner, name)): Path<(String, String)>,
2849 
    Query(q): Query<RunsPage>,
2850 
) -> Result<Json<Vec<FlowRun>>, ApiError> {
2851 
    let c = caller(&app, &headers).await?;
2852 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2853 
    let limit = q.limit.unwrap_or(30).clamp(1, 100);
2854 
    let runs = db::flow::runs_by_number(&app.db, row.id, limit, q.before).await?;
bf3d0754 Andy McCall ↶ 2855 
    let queue = if runs.iter().any(|r| r.live()) { db::flow::queue(&app.db).await? } else { vec![] };
2856 
    Ok(Json(runs.iter().map(|r| flow_run_of(&app, &row, r, vec![], &queue)).collect()))
90326c96 Andy McCall ↶ 2857 
}
2858
2859 
/// `GET /repos/{o}/{n}/flow/runs/{number}`: a run with its jobs.
2860 
async fn flow_run(
2861 
    State(app): State<Shared>,
2862 
    headers: HeaderMap,
2863 
    Path((owner, name, number)): Path<(String, String, i64)>,
2864 
) -> Result<Json<FlowRun>, ApiError> {
2865 
    let c = caller(&app, &headers).await?;
2866 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2867 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2868 
    let jobs = db::flow::jobs(&app.db, run.id).await?;
bf3d0754 Andy McCall ↶ 2869 
    let queue = if run.live() { db::flow::queue(&app.db).await? } else { vec![] };
2870 
    Ok(Json(flow_run_of(&app, &row, &run, jobs, &queue)))
90326c96 Andy McCall ↶ 2871 
}
2872
2873 
#[derive(Deserialize)]
2874 
struct LogPage {
2875 
    /// Lines after this `seq`.
2876 
    #[serde(default)]
2877 
    after: i64,
2878 
    limit: Option<i64>,
2879 
}
2880
2881 
/// `GET /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/log`: `?after=seq&limit=` (max 5000).
2882 
async fn flow_job_log(
2883 
    State(app): State<Shared>,
2884 
    headers: HeaderMap,
2885 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2886 
    Query(q): Query<LogPage>,
2887 
) -> Result<Json<Vec<FlowLogLine>>, ApiError> {
2888 
    let c = caller(&app, &headers).await?;
2889 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2890 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2891 
    let j = db::flow::jobs(&app.db, run.id)
2892 
        .await?
2893 
        .into_iter()
2894 
        .find(|j| j.name == job)
2895 
        .ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such job".into()))?;
2896 
    let lines = db::flow::log(&app.db, j.id, q.after, q.limit.unwrap_or(1000).clamp(1, 5000)).await?;
2897 
    Ok(Json(lines.into_iter().map(|l| FlowLogLine { seq: l.seq, t: l.t, stream: l.stream, text: l.text }).collect()))
2898 
}
2899
2900 
#[derive(Deserialize)]
1edac4b6 Andy McCall ↶ 2901 
struct StartRun {
2902 
    /// Default: the repository's default bookmark.
2903 
    #[serde(default)]
2904 
    bookmark: Option<String>,
4f692533 Andy McCall ↶ 2905 
    /// A change's full hash: run the state whose only head it is, instead
2906 
    /// of a bookmark's.
2907 
    #[serde(default)]
2908 
    change: Option<String>,
0650d94e Andy McCall ↶ 2909 
    /// Only these jobs, with what they depend on (oxygenhub#130); default:
2910 
    /// every job a manual run starts.
2911 
    #[serde(default)]
2912 
    jobs: Vec<String>,
1edac4b6 Andy McCall ↶ 2913 
}
2914
2915 
fn started(app: &Shared, row: &db::repos::RepoRow, number: i64) -> (StatusCode, Json<serde_json::Value>) {
2916 
    let url = format!("{}/{}/{}/flow/{number}", app.config.base_url(), row.owner, row.name);
2917 
    (StatusCode::CREATED, Json(serde_json::json!({ "number": number, "url": url })))
2918 
}
2919
2920 
/// `POST /repos/{o}/{n}/flow/runs` (repo:write): run a bookmark's current
4f692533 Andy McCall ↶ 2921 
/// state, or one change's, without moving anything (hub spec §13.2).
1edac4b6 Andy McCall ↶ 2922 
async fn start_flow_run(
2923 
    State(app): State<Shared>,
2924 
    headers: HeaderMap,
2925 
    Path((owner, name)): Path<(String, String)>,
2926 
    Json(body): Json<StartRun>,
2927 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2928 
    let c = caller(&app, &headers).await?;
2929 
    let me = c.require("repo:write")?.clone();
2930 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
0650d94e Andy McCall ↶ 2931 
    let (n, what) = match body.change.clone().filter(|c| !c.trim().is_empty()) {
4f692533 Andy McCall ↶ 2932 
        Some(change) => {
0650d94e Andy McCall ↶ 2933 
            let n = crate::flow::run_change(&app, &row, &change, &me.username, &body.jobs)
2934 
                .await
2935 
                .map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
4f692533 Andy McCall ↶ 2936 
            (n, format!("change {}", change.trim()))
2937 
        }
2938 
        None => {
2939 
            let bookmark = body.bookmark.unwrap_or_else(|| row.default_bookmark.clone());
0650d94e Andy McCall ↶ 2940 
            (
2941 
                crate::flow::run_bookmark(&app, &row, &bookmark, &me.username, &body.jobs)
2942 
                    .await
2943 
                    .map_err(|m| ApiError(StatusCode::CONFLICT, m))?,
2944 
                bookmark,
2945 
            )
4f692533 Andy McCall ↶ 2946 
        }
2947 
    };
2948 
    db::accounts::audit(&app.db, Some(&me), "flow.run", &format!("{owner}/{name}"), &format!("#{n} {what}")).await.ok();
1edac4b6 Andy McCall ↶ 2949 
    Ok(started(&app, &row, n))
2950 
}
2951
2952 
/// `POST /repos/{o}/{n}/flow/runs/{number}/rerun` (repo:write).
2953 
async fn rerun_flow_run(
2954 
    State(app): State<Shared>,
2955 
    headers: HeaderMap,
2956 
    Path((owner, name, number)): Path<(String, String, i64)>,
2957 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2958 
    let c = caller(&app, &headers).await?;
2959 
    let me = c.require("repo:write")?.clone();
2960 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2961 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2962 
    let n = crate::flow::rerun(&app, &row, &run, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2963 
    db::accounts::audit(&app.db, Some(&me), "flow.rerun", &format!("{owner}/{name}"), &format!("#{n} of #{number}")).await.ok();
2964 
    Ok(started(&app, &row, n))
d23464c0 Andy McCall ↶ 2965 
}
2966
e8fa5369 Andy McCall ↶ 2967 
/// `POST /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/rerun` (repo:write,
2968 
/// oxygenflow#31): that job again, with the jobs that depend on it, in the
2969 
/// same run. Answers with how many jobs were queued.
2970 
async fn rerun_flow_job(
2971 
    State(app): State<Shared>,
2972 
    headers: HeaderMap,
2973 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2974 
) -> Result<Json<serde_json::Value>, ApiError> {
2975 
    let c = caller(&app, &headers).await?;
2976 
    let me = c.require("repo:write")?.clone();
2977 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2978 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2979 
    let n = crate::flow::rerun_job(&app, &row, &run, &job, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2980 
    db::accounts::audit(&app.db, Some(&me), "flow.rerun", &format!("{owner}/{name}"), &format!("{job} of #{number}")).await.ok();
2981 
    Ok(Json(serde_json::json!({ "run": number, "job": job, "queued": n })))
2982 
}
2983
745d225d Andy McCall ↶ 2984 
/// `POST /repos/{o}/{n}/flow/runs/{number}/cancel` (repo:write): answers
2985 
/// with the run as it now stands.
2986 
async fn cancel_flow_run(
2987 
    State(app): State<Shared>,
2988 
    headers: HeaderMap,
2989 
    Path((owner, name, number)): Path<(String, String, i64)>,
2990 
) -> Result<Json<serde_json::Value>, ApiError> {
2991 
    let c = caller(&app, &headers).await?;
2992 
    let me = c.require("repo:write")?.clone();
2993 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2994 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2995 
    crate::flow::cancel(&app, &row, &run, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2996 
    db::accounts::audit(&app.db, Some(&me), "flow.cancel", &format!("{owner}/{name}"), &format!("#{number}")).await.ok();
2997 
    Ok(Json(serde_json::json!({ "number": number, "status": "cancelled" })))
2998 
}
2999
b644e175 Andy McCall ↶ 3000 
/// `GET /repos/{o}/{n}/deployments`: deployments, newest first
3001 
/// (oxygenflow#59).
3002 
async fn list_deployments(
3003 
    State(app): State<Shared>,
3004 
    headers: HeaderMap,
3005 
    Path((owner, name)): Path<(String, String)>,
3006 
) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
3007 
    let c = caller(&app, &headers).await?;
3008 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
3009 
    let list = db::flow::deployments(&app.db, row.id, 100).await?;
3010 
    Ok(Json(
3011 
        list.into_iter()
3012 
            .map(|d| {
3013 
                serde_json::json!({ "environment": d.environment, "job": d.job, "run": d.run_number, "state": d.state,
3014 
                    "bookmark": d.bookmark, "actor": d.actor, "approved_by": d.approved_by, "finished_ms": d.finished_ms })
3015 
            })
3016 
            .collect(),
3017 
    ))
3018 
}
3019
b1860d60 Andy McCall ↶ 3020 
#[derive(Deserialize)]
3021 
struct ExpediteBody {
3022 
    reason: String,
3023 
}
3024
3025 
/// `POST /repos/{o}/{n}/flow/runs/{number}/expedite {"reason": …}`
3026 
/// (oxygenhub#244): a maintainer makes a queued or running run urgent, as
3027 
/// the run page's Expedite does, within the owner's cap of urgent runs.
3028 
async fn expedite_flow_run(
3029 
    State(app): State<Shared>,
3030 
    headers: HeaderMap,
3031 
    Path((owner, name, number)): Path<(String, String, i64)>,
3032 
    Json(body): Json<ExpediteBody>,
3033 
) -> Result<Json<serde_json::Value>, ApiError> {
3034 
    let c = caller(&app, &headers).await?;
3035 
    let me = c.require("repo:write")?.clone();
3036 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
3037 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such run"))?;
3038 
    crate::flow::expedite(&app, &row, &run, &me, &body.reason).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
3039 
    Ok(Json(serde_json::json!({ "number": number, "expedited": true })))
3040 
}
3041
417184c7 Andy McCall ↶ 3042 
/// `POST /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/approve` and
3043 
/// `.../reject` (oxygenflow#57): the job's approval rules decide who may.
3044 
async fn approve_flow_job(
3045 
    State(app): State<Shared>,
3046 
    headers: HeaderMap,
3047 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
3048 
) -> Result<Json<serde_json::Value>, ApiError> {
3049 
    decide_flow_job(&app, &headers, &owner, &name, number, &job, true).await
3050 
}
3051
3052 
async fn reject_flow_job(
3053 
    State(app): State<Shared>,
3054 
    headers: HeaderMap,
3055 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
3056 
) -> Result<Json<serde_json::Value>, ApiError> {
3057 
    decide_flow_job(&app, &headers, &owner, &name, number, &job, false).await
3058 
}
3059
47e37402 Andy McCall ↶ 3060 
/// `GET .../flow/runs/{n}/jobs/{job}/approval`: what approving the job
3061 
/// means, for `oxy seal --flow` to sign (oxygenhub#235).
3062 
async fn flow_job_statement(
3063 
    State(app): State<Shared>,
3064 
    headers: HeaderMap,
3065 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
3066 
) -> Result<Json<serde_json::Value>, ApiError> {
3067 
    let c = caller(&app, &headers).await?;
3068 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
3069 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
3070 
    let (s, j) = crate::flow::approval_statement(&app, &row, &run, &job).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
3071 
    Ok(Json(serde_json::json!({
3072 
        "repo": hex::encode(s.repo),
3073 
        "run": s.run,
3074 
        "job": s.job,
3075 
        "job_hash": s.job_hash.to_hex(),
3076 
        "state": s.state.to_hex(),
3077 
        "inputs": s.inputs.iter().map(|i| i.to_hex()).collect::<Vec<_>>(),
3078 
        "environment": s.environment,
3079 
        "waiting": j.approval == "waiting" && j.status == "queued",
3080 
    })))
3081 
}
3082
3083 
#[derive(Deserialize)]
3084 
struct SealBody {
3085 
    signed: String,
3086 
}
3087
3088 
/// `POST .../flow/runs/{n}/jobs/{job}/seal` `{"signed": hex}`: approve or
3089 
/// reject with a signed approval (oxygenhub#235). The signature, not the
3090 
/// caller, says who decided; the caller must be signed in.
3091 
async fn seal_flow_job(
3092 
    State(app): State<Shared>,
3093 
    headers: HeaderMap,
3094 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
3095 
    Json(body): Json<SealBody>,
3096 
) -> Result<Json<serde_json::Value>, ApiError> {
3097 
    let c = caller(&app, &headers).await?;
3098 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
3099 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
3100 
    let said = crate::flow::decide_sealed(&app, &row, &run, &job, &body.signed).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
3101 
    Ok(Json(serde_json::json!({ "number": number, "job": job, "said": said })))
3102 
}
3103
417184c7 Andy McCall ↶ 3104 
async fn decide_flow_job(
3105 
    app: &Shared,
3106 
    headers: &HeaderMap,
3107 
    owner: &str,
3108 
    name: &str,
3109 
    number: i64,
3110 
    job: &str,
3111 
    approve: bool,
3112 
) -> Result<Json<serde_json::Value>, ApiError> {
3113 
    let c = caller(app, headers).await?;
3114 
    let me = c.require("repo:write")?.clone();
3115 
    let (_, row, _) = reach(app, &c, owner, name, Access::Read).await?;
3116 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
05f1a85a Andy McCall ↶ 3117 
    let via = c.agent.then_some(c.token.as_str());
3118 
    let said = crate::flow::decide(app, &row, &run, job, &me, approve, via).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
417184c7 Andy McCall ↶ 3119 
    Ok(Json(serde_json::json!({ "number": number, "job": job, "decision": if approve { "approved" } else { "rejected" }, "said": said })))
3120 
}
3121
b64e2537 Andy McCall ↶ 3122 
/// `POST /repos/{o}/{n}/checks`: any `checks:write` (or write) token may
3123 
/// report; the state hash names what was checked.
3124 
async fn post_check(
3125 
    State(app): State<Shared>,
3126 
    headers: HeaderMap,
3127 
    Path((owner, name)): Path<(String, String)>,
3128 
    Json(body): Json<NewCheck>,
3129 
) -> Result<(StatusCode, Json<Check>), ApiError> {
3130 
    let c = caller(&app, &headers).await?;
3131 
    let me = c.require("checks:write").or_else(|_| c.require("repo:write"))?.clone();
3132 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
3133 
    if body.state.len() != 64 || !body.state.chars().all(|ch| ch.is_ascii_hexdigit()) {
3134 
        return Err(ApiError(StatusCode::BAD_REQUEST, "state is a 64-character hex state hash".into()));
3135 
    }
3136 
    if body.name.trim().is_empty() || body.name.len() > 100 {
3137 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a check has a short name".into()));
3138 
    }
3139 
    let ch = db::hooks::upsert_check(
3140 
        &app.db,
3141 
        row.id,
db72849c Andy McCall ↶ 3142 
        db::hooks::CheckReport {
3143 
            state: &body.state,
3144 
            name: body.name.trim(),
3145 
            status: body.status.as_str(),
3146 
            summary: &body.summary,
3147 
            url: &body.url,
3148 
            reporter: Some((me.id, &me.username)),
3149 
            seal: body.seal.as_deref().unwrap_or(""),
3150 
        },
b64e2537 Andy McCall ↶ 3151 
    )
3152 
    .await?;
3153 
    let api = check_of(&ch);
33d98147 Andy McCall 3154 
    app.bus.proposal(row.id, ProposalEvent { number: 0, kind: "check".into(), check: Some(api.clone()) });
b64e2537 Andy McCall ↶ 3155 
    crate::hooks::emit(&app, &row, "check", &me.username, serde_json::json!({ "check": api })).await;
3156 
    Ok((StatusCode::CREATED, Json(api)))
d23464c0 Andy McCall ↶ 3157 
}
3158
b64e2537 Andy McCall ↶ 3159 
async fn checks_for_state(
3160 
    State(app): State<Shared>,
3161 
    headers: HeaderMap,
3162 
    Path((owner, name, state)): Path<(String, String, String)>,
3163 
) -> Result<Json<Vec<Check>>, ApiError> {
3164 
    let c = caller(&app, &headers).await?;
90326c96 Andy McCall ↶ 3165 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
3166 
    let state = state_key(&app, &repo, &state).await?;
b64e2537 Andy McCall ↶ 3167 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &state).await?.iter().map(check_of).collect()))
90326c96 Andy McCall ↶ 3168 
}
3169
3170 
/// The state hash checks are keyed by, from what a client has: a state
3171 
/// hash, its heads (full change hashes joined with `+`, or the one head of
3172 
/// a single-head state, which is what `oxy log` shows), or a bookmark.
3173 
async fn state_key(app: &Shared, repo: &RepoName, s: &str) -> Result<String, ApiError> {
3174 
    use oxy_core::hash::{hash_object, ChangeHash, ObjectType};
3175 
    let hexes: Vec<&str> = s.split('+').collect();
3176 
    let all_hashes = hexes.iter().all(|h| h.len() == 64 && h.bytes().all(|b| b.is_ascii_hexdigit()));
3177 
    if all_hashes {
3178 
        let row = db::repos::get(&app.db, &repo.owner, &repo.name).await?.ok_or_else(|| not_found("no such repository"))?;
3179 
        if hexes.len() == 1 && !db::hooks::checks_for_state(&app.db, row.id, s).await?.is_empty() {
3180 
            return Ok(s.to_string());
3181 
        }
3182 
        let heads: Vec<ChangeHash> = hexes.iter().filter_map(|h| ChangeHash::from_hex(h)).collect();
3183 
        return Ok(hash_object(ObjectType::State, &oxy_core::objects::StateObject::new(heads).encode()).to_hex());
3184 
    }
3185 
    let b = s.to_string();
3186 
    let found = app.repos.read(repo, move |r, _| Ok(r.view()?.bookmarks.get(&b).copied())).await?;
3187 
    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 ↶ 3188 
}
b66e70b7 Andy McCall ↶ 3189
3190 
// ----------------------------------------------------------------- runners
3191
3192 
/// Site administrators only, with any token of theirs (hub spec §13.2).
3193 
fn require_site_admin(c: &Caller) -> Result<&Account, ApiError> {
3194 
    match c.account.as_ref() {
3195 
        Some(a) if a.is_admin => Ok(a),
3196 
        _ => Err(not_found("no such API route")),
3197 
    }
3198 
}
3199
9bbca80f Andy McCall ↶ 3200 
/// `GET /api/v1/admin/runner-updates` (oxygenhub#322, #326).
3201 
async fn runner_updates(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<RunnerUpdates>, ApiError> {
3202 
    let c = caller(&app, &headers).await?;
3203 
    require_site_admin(&c)?;
3204 
    use crate::web::runner_updates::{views, Reach};
3205 
    let v = views(&app, &Reach::Site).await?;
3206 
    let setting = |p: &crate::web::runner_updates::PolicyView| UpdateSetting {
3207 
        scope: p.scope.clone(),
3208 
        key: p.key.clone(),
3209 
        updates: match p.updates {
3210 
            "on" => Some(true),
3211 
            "off" => Some(false),
3212 
            _ => None,
3213 
        },
3214 
        channel: Some(p.channel.clone()).filter(|c| !c.is_empty()),
3215 
        window: Some(p.window.clone()).filter(|w| !w.is_empty()),
3216 
        dry_run: match p.dry_run {
3217 
            "on" => Some(true),
3218 
            "off" => Some(false),
3219 
            _ => None,
3220 
        },
3221 
    };
3222 
    let mut settings = vec![setting(&v.site)];
3223 
    settings.extend(v.owners.iter().map(setting));
3224 
    settings.extend(v.groups.iter().map(|g| setting(&g.policy)));
3225 
    settings.extend(v.runners.iter().map(|r| setting(&r.policy)));
3226 
    settings.retain(|s| s.scope == "site" || s.updates.is_some() || s.channel.is_some() || s.window.is_some() || s.dry_run.is_some());
3227 
    Ok(Json(RunnerUpdates {
3228 
        repo: db::accounts::setting(&app.db, crate::runner_updates::SETTING_REPO).await?.unwrap_or_default(),
3229 
        settings,
3230 
        groups: v
3231 
            .groups
3232 
            .iter()
3233 
            .map(|g| RunnerGroup {
3234 
                id: g.g.id,
3235 
                owner: g.g.owner.clone(),
3236 
                name: g.g.name.clone(),
3237 
                percent: g.g.percent,
3238 
                members: g.members.clone(),
1ec29691 Andy McCall ↶ 3239 
                wave: g.g.wave,
9bbca80f Andy McCall ↶ 3240 
            })
3241 
            .collect(),
3242 
        runners: v
3243 
            .runners
3244 
            .iter()
3245 
            .map(|r| RunnerUpdate {
3246 
                id: r.r.id,
3247 
                name: r.r.name.clone(),
3248 
                owner: r.r.scope_owner.clone(),
3249 
                version: r.r.version.clone(),
3250 
                groups: r.groups.clone(),
3251 
                updates: r.effective.updates,
3252 
                channel: r.effective.channel.clone(),
3253 
                window: r.effective.window.map(|(a, b)| format!("{a:02}-{b:02}")),
3254 
                dry_run: r.effective.dry_run,
3255 
                from: r.effective.from.clone(),
3256 
                now: r.offer.clone(),
3257 
                said: r.r.update_note.clone(),
3258 
            })
3259 
            .collect(),
3260 
        holds: db::runner_updates::holds(&app.db)
3261 
            .await?
3262 
            .into_iter()
3263 
            .map(|h| HeldBuild { version: h.version, runner: h.runner, why: h.why, at_ms: h.at_ms })
3264 
            .collect(),
3265 
    }))
3266 
}
3267
3268 
/// `PUT /api/v1/admin/runner-updates/settings`: one level's settings; what
3269 
/// it set, in words, or 422 saying what is wrong.
3270 
async fn runner_update_setting(
3271 
    State(app): State<Shared>,
3272 
    headers: HeaderMap,
3273 
    Json(u): Json<UpdateSetting>,
3274 
) -> Result<Json<serde_json::Value>, ApiError> {
3275 
    let c = caller(&app, &headers).await?;
3276 
    let me = require_site_admin(&c)?.clone();
3277 
    use crate::web::runner_updates::{apply_policy, PolicyForm, Reach};
3278 
    match apply_policy(&app, &me, &Reach::Site, &PolicyForm::of(&u)).await? {
3279 
        Ok(notice) => Ok(Json(serde_json::json!({ "notice": notice }))),
3280 
        Err(why) => Err(ApiError(StatusCode::UNPROCESSABLE_ENTITY, why)),
3281 
    }
3282 
}
3283
3284 
/// `POST /api/v1/admin/runner-updates/holds/{version}/lift` (#326).
3285 
async fn runner_update_lift(State(app): State<Shared>, headers: HeaderMap, Path(version): Path<String>) -> Result<StatusCode, ApiError> {
3286 
    let c = caller(&app, &headers).await?;
3287 
    let me = require_site_admin(&c)?.clone();
3288 
    if !db::runner_updates::lift(&app.db, &version).await? {
3289 
        return Err(not_found("that build is not held"));
3290 
    }
3291 
    db::accounts::audit(&app.db, Some(&me), "runner.update.lifted", &version, "offered again").await.ok();
3292 
    Ok(StatusCode::NO_CONTENT)
3293 
}
3294
b66e70b7 Andy McCall ↶ 3295 
async fn runner_of(app: &Shared, r: db::runners::Runner, running: i64) -> hub_api::Runner {
3296 
    let serves = match r.scope_repo_id {
3297 
        Some(id) => db::repos::get_by_id(&app.db, id).await.ok().flatten().map(|p| p.slug()).unwrap_or_default(),
3298 
        None => r.scope_owner.clone(),
3299 
    };
3300 
    hub_api::Runner {
3301 
        id: r.id,
3302 
        status: r.status().to_string(),
3303 
        serves,
3304 
        labels: r.label_list().into_iter().map(String::from).collect(),
3305 
        name: r.name,
3306 
        arch: r.arch,
3307 
        os: r.os,
3308 
        version: r.version,
3309 
        max_jobs: r.max_jobs,
3310 
        memory_mib: r.memory_mib,
3311 
        cpus: r.cpus,
3312 
        key: r.key,
3313 
        source: r.source,
3314 
        last_seen_ms: r.last_seen_ms,
3315 
        running,
2fb70d01 Andy McCall ↶ 3316 
        free_disk_mib: r.free_disk_mib,
3317 
        load_x100: r.load_x100,
3318 
        speed: r.speed,
3319 
        speed_class: r.speed_class,
3320 
        kernel: r.kernel,
b66e70b7 Andy McCall ↶ 3321 
    }
3322 
}
3323
3324 
/// `GET /api/v1/runners`.
3325 
async fn runners(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::Runner>>, ApiError> {
3326 
    let c = caller(&app, &headers).await?;
3327 
    require_site_admin(&c)?;
3328 
    let running: std::collections::HashMap<i64, i64> = db::runners::running(&app.db).await?.into_iter().collect();
3329 
    let mut out = Vec::new();
3330 
    for r in db::runners::list(&app.db).await? {
3331 
        let n = running.get(&r.id).copied().unwrap_or(0);
3332 
        out.push(runner_of(&app, r, n).await);
3333 
    }
3334 
    Ok(Json(out))
3335 
}
3336
3337 
#[derive(Deserialize)]
3338 
struct BeforeQuery {
3339 
    #[serde(default)]
3340 
    before: Option<i64>,
3341 
    #[serde(default)]
3342 
    limit: Option<i64>,
3343 
}
3344
3345 
/// `GET /api/v1/runners/{id}/jobs?before=MS&limit=N`: newest first.
3346 
async fn runner_jobs(
3347 
    State(app): State<Shared>,
3348 
    headers: HeaderMap,
3349 
    Path(id): Path<i64>,
3350 
    Query(q): Query<BeforeQuery>,
3351 
) -> Result<Json<Vec<hub_api::RunnerJob>>, ApiError> {
3352 
    let c = caller(&app, &headers).await?;
3353 
    require_site_admin(&c)?;
3354 
    db::runners::get(&app.db, id).await?.ok_or_else(|| not_found("no such runner"))?;
3355 
    let jobs = db::runners::history(&app.db, id, q.limit.unwrap_or(50).clamp(1, 200), q.before).await?;
3356 
    Ok(Json(
3357 
        jobs.into_iter()
3358 
            .map(|j| hub_api::RunnerJob {
3359 
                repo: format!("{}/{}", j.owner, j.repo),
3360 
                run: j.run_number,
3361 
                job: j.job,
3362 
                status: j.status,
3363 
                started_ms: j.started_ms,
3364 
                finished_ms: j.finished_ms,
3365 
            })
3366 
            .collect(),
3367 
    ))
3368 
}
3369
3370 
/// `GET /api/v1/runners/queue`: running jobs, then queued ones in claim order.
3371 
async fn runner_queue(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::QueueItem>>, ApiError> {
3372 
    let c = caller(&app, &headers).await?;
3373 
    require_site_admin(&c)?;
3374 
    Ok(Json(
3375 
        db::flow::queue(&app.db)
3376 
            .await?
3377 
            .into_iter()
3378 
            .map(|e| hub_api::QueueItem {
3379 
                repo: format!("{}/{}", e.owner, e.name),
3380 
                run: e.run_number,
3381 
                job: e.job,
3382 
                status: e.status,
3383 
                runner: e.runner,
3384 
            })
3385 
            .collect(),
3386 
    ))
3387 
}
7d2eb590 Andy McCall ↶ 3388
3389 
/// `POST .../proposals/{number}/review-requests`: ask an AI assistant the
3390 
/// repository may use to review (hub spec §13.4). Accepted at once; the
3391 
/// answer arrives as a `comment` review via the assistant.
3392 
async fn request_assistant(
3393 
    State(app): State<Shared>,
3394 
    headers: HeaderMap,
3395 
    Path((owner, name, number)): Path<(String, String, i64)>,
3396 
    Json(body): Json<hub_api::AssistantRequest>,
3397 
) -> Result<(StatusCode, Json<hub_api::AssistantRequest>), ApiError> {
3398 
    let c = caller(&app, &headers).await?;
3399 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
3400 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
3401 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3402 
    if Some(me.id) != p.author_id && role < Role::Write {
3403 
        return Err(forbidden("only the author or a writer asks for reviews"));
3404 
    }
3405 
    if !p.is_open() {
3406 
        return Err(ApiError(StatusCode::CONFLICT, "the proposal is not open".into()));
3407 
    }
3408 
    let a = crate::assistants::enabled_for_repo(&app.db, &row)
3409 
        .await?
3410 
        .into_iter()
3411 
        .find(|a| a.name.eq_ignore_ascii_case(body.assistant.trim()))
3412 
        .ok_or_else(|| ApiError(StatusCode::UNPROCESSABLE_ENTITY, format!("no assistant called {} here", body.assistant.trim())))?;
3413 
    let asked = hub_api::AssistantRequest { assistant: a.name.clone() };
3414 
    crate::assistants::request_review(&app, &row, &p, &me, a).await.map_err(|e| ApiError(StatusCode::CONFLICT, e))?;
3415 
    Ok((StatusCode::ACCEPTED, Json(asked)))
3416 
}
62ceb2ee Andy McCall ↶ 3417
3418 
// -------------------------------------------------------- assistants (§13.4)
3419
3420 
use crate::levels::At;
3421 
use crate::web::assistants as aa;
3422
3423 
/// The level a repository's assistants live at, for its admins (repo:admin).
3424 
async fn repo_level(app: &Shared, c: &Caller, owner: &str, name: &str) -> Result<(Account, At), ApiError> {
3425 
    let me = c.require("repo:admin")?.clone();
3426 
    let (_, row, _) = reach(app, c, owner, name, Access::Admin).await?;
3427 
    Ok((me, At::repo(&row)))
3428 
}
3429
3430 
/// An organisation's level, for its owners (repo:admin).
3431 
async fn org_level(app: &Shared, c: &Caller, org: &str) -> Result<(Account, At), ApiError> {
3432 
    let me = c.require("repo:admin")?.clone();
3433 
    let o = db::accounts::org_by_name(&app.db, org).await?.ok_or_else(|| not_found("no such organisation"))?;
3434 
    if !auth::roles::is_org_owner(&app.db, &me, o.id).await? {
3435 
        return Err(not_found("no such organisation"));
3436 
    }
3437 
    Ok((me, At::org(&o)))
3438 
}
3439
3440 
/// The site's level, for its administrators.
3441 
fn site_level(c: &Caller) -> Result<(Account, At), ApiError> {
3442 
    Ok((require_site_admin(c)?.clone(), At::site()))
3443 
}
3444
3445 
fn put_outcome(r: Result<String, String>) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
3446 
    match r {
3447 
        Ok(msg) => Ok((StatusCode::OK, Json(serde_json::json!({ "ok": msg })))),
3448 
        Err(e) => Err(ApiError(StatusCode::UNPROCESSABLE_ENTITY, e)),
3449 
    }
3450 
}
3451
3452 
macro_rules! assistant_routes {
3453 
    ($list:ident, $put:ident, $del:ident, $prompt:ident, $prompt_put:ident, ($($p:ident: $t:ty),*), $level:expr) => {
3454 
        async fn $list(State(app): State<Shared>, headers: HeaderMap, Path(($($p),*)): Path<($($t),*)>) -> Result<Json<Vec<Assistant>>, ApiError> {
3455 
            let c = caller(&app, &headers).await?;
3456 
            let (_, at) = $level(&app, &c, $(&$p),*).await?;
3457 
            Ok(Json(aa::api_list(&app, &at).await?))
3458 
        }
3459 
        async fn $put(
3460 
            State(app): State<Shared>,
3461 
            headers: HeaderMap,
3462 
            Path(($($p),*)): Path<($($t),*)>,
3463 
            Json(body): Json<NewAssistant>,
3464 
        ) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
3465 
            let c = caller(&app, &headers).await?;
3466 
            let (me, at) = $level(&app, &c, $(&$p),*).await?;
3467 
            put_outcome(aa::api_put(&app, &me, &at, body).await?)
3468 
        }
3469 
        async fn $prompt(State(app): State<Shared>, headers: HeaderMap, Path(($($p),*)): Path<($($t),*)>) -> Result<Json<AssistantPrompt>, ApiError> {
3470 
            let c = caller(&app, &headers).await?;
3471 
            let (_, at) = $level(&app, &c, $(&$p),*).await?;
3472 
            Ok(Json(aa::api_prompt(&app, &at).await?))
3473 
        }
3474 
        async fn $prompt_put(
3475 
            State(app): State<Shared>,
3476 
            headers: HeaderMap,
3477 
            Path(($($p),*)): Path<($($t),*)>,
3478 
            Json(body): Json<AssistantPrompt>,
3479 
        ) -> Result<Json<AssistantPrompt>, ApiError> {
3480 
            let c = caller(&app, &headers).await?;
3481 
            let (me, at) = $level(&app, &c, $(&$p),*).await?;
3482 
            aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
3483 
            Ok(Json(aa::api_prompt(&app, &at).await?))
3484 
        }
3485 
    };
3486 
}
3487
3488 
assistant_routes!(repo_assistants, repo_assistant_put, _rd, repo_prompt, repo_prompt_put, (owner: String, name: String), repo_level);
3489
3490 
async fn repo_assistant_delete(
3491 
    State(app): State<Shared>,
3492 
    headers: HeaderMap,
3493 
    Path((owner, name, assistant)): Path<(String, String, String)>,
3494 
) -> Result<StatusCode, ApiError> {
3495 
    let c = caller(&app, &headers).await?;
3496 
    let (me, at) = repo_level(&app, &c, &owner, &name).await?;
3497 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
3498 
        Ok(StatusCode::NO_CONTENT)
3499 
    } else {
3500 
        Err(not_found("no such assistant at this level"))
3501 
    }
3502 
}
3503
3504 
async fn org_level_one(app: &Shared, c: &Caller, org: &str) -> Result<(Account, At), ApiError> {
3505 
    org_level(app, c, org).await
3506 
}
3507
3508 
async fn org_assistants(State(app): State<Shared>, headers: HeaderMap, Path(org): Path<String>) -> Result<Json<Vec<Assistant>>, ApiError> {
3509 
    let c = caller(&app, &headers).await?;
3510 
    let (_, at) = org_level_one(&app, &c, &org).await?;
3511 
    Ok(Json(aa::api_list(&app, &at).await?))
3512 
}
3513
3514 
async fn org_assistant_put(
3515 
    State(app): State<Shared>,
3516 
    headers: HeaderMap,
3517 
    Path(org): Path<String>,
3518 
    Json(body): Json<NewAssistant>,
3519 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
3520 
    let c = caller(&app, &headers).await?;
3521 
    let (me, at) = org_level_one(&app, &c, &org).await?;
3522 
    put_outcome(aa::api_put(&app, &me, &at, body).await?)
3523 
}
3524
3525 
async fn org_assistant_delete(
3526 
    State(app): State<Shared>,
3527 
    headers: HeaderMap,
3528 
    Path((org, assistant)): Path<(String, String)>,
3529 
) -> Result<StatusCode, ApiError> {
3530 
    let c = caller(&app, &headers).await?;
3531 
    let (me, at) = org_level_one(&app, &c, &org).await?;
3532 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
3533 
        Ok(StatusCode::NO_CONTENT)
3534 
    } else {
3535 
        Err(not_found("no such assistant at this level"))
3536 
    }
3537 
}
3538
3539 
async fn org_prompt(State(app): State<Shared>, headers: HeaderMap, Path(org): Path<String>) -> Result<Json<AssistantPrompt>, ApiError> {
3540 
    let c = caller(&app, &headers).await?;
3541 
    let (_, at) = org_level_one(&app, &c, &org).await?;
3542 
    Ok(Json(aa::api_prompt(&app, &at).await?))
3543 
}
3544
3545 
async fn org_prompt_put(
3546 
    State(app): State<Shared>,
3547 
    headers: HeaderMap,
3548 
    Path(org): Path<String>,
3549 
    Json(body): Json<AssistantPrompt>,
3550 
) -> Result<Json<AssistantPrompt>, ApiError> {
3551 
    let c = caller(&app, &headers).await?;
3552 
    let (me, at) = org_level_one(&app, &c, &org).await?;
3553 
    aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
3554 
    Ok(Json(aa::api_prompt(&app, &at).await?))
3555 
}
3556
3557 
async fn site_assistants(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Assistant>>, ApiError> {
3558 
    let c = caller(&app, &headers).await?;
3559 
    let (_, at) = site_level(&c)?;
3560 
    Ok(Json(aa::api_list(&app, &at).await?))
3561 
}
3562
3563 
async fn site_assistant_put(
3564 
    State(app): State<Shared>,
3565 
    headers: HeaderMap,
3566 
    Json(body): Json<NewAssistant>,
3567 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
3568 
    let c = caller(&app, &headers).await?;
3569 
    let (me, at) = site_level(&c)?;
3570 
    put_outcome(aa::api_put(&app, &me, &at, body).await?)
3571 
}
3572
3573 
async fn site_assistant_delete(
3574 
    State(app): State<Shared>,
3575 
    headers: HeaderMap,
3576 
    Path(assistant): Path<String>,
3577 
) -> Result<StatusCode, ApiError> {
3578 
    let c = caller(&app, &headers).await?;
3579 
    let (me, at) = site_level(&c)?;
3580 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
3581 
        Ok(StatusCode::NO_CONTENT)
3582 
    } else {
3583 
        Err(not_found("no such assistant at this level"))
3584 
    }
3585 
}
3586
3587 
async fn site_prompt(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<AssistantPrompt>, ApiError> {
3588 
    let c = caller(&app, &headers).await?;
3589 
    let (_, at) = site_level(&c)?;
3590 
    Ok(Json(aa::api_prompt(&app, &at).await?))
3591 
}
3592
3593 
async fn site_prompt_put(
3594 
    State(app): State<Shared>,
3595 
    headers: HeaderMap,
3596 
    Json(body): Json<AssistantPrompt>,
3597 
) -> Result<Json<AssistantPrompt>, ApiError> {
3598 
    let c = caller(&app, &headers).await?;
3599 
    let (me, at) = site_level(&c)?;
3600 
    aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
3601 
    Ok(Json(aa::api_prompt(&app, &at).await?))
3602 
}