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