Proposals from feature/ bookmarks; a landing says who and how 0b20f1ec4007

-- Who landed a proposal, how (from the web, or through the API with which

-- token) and when (oxygenhub#47, #48).

ALTER TABLE proposals ADD COLUMN landed_by TEXT NOT NULL DEFAULT '';

ALTER TABLE proposals ADD COLUMN landed_via TEXT NOT NULL DEFAULT '';

ALTER TABLE proposals ADD COLUMN landed_ms INTEGER NOT NULL DEFAULT 0;

    /// Who landed it, how and when, once landed.

    #[serde(default)]

    pub landed: Option<Landed>,

}

/// How a proposal was landed.

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]

pub struct Landed {

    pub by: String,

    /// `web`, or `api (token NAME)`.

    pub via: String,

    pub when_ms: i64,

    /// The token's name, for records of what a call did.

    pub token: String,

    let Some(t) = oxy_server::bearer_token(headers) else {

        return Ok(Caller { account: None, scopes: vec![], site: false, token: String::new() });

    };

        return Ok(Caller {

            account: admin,

            scopes: vec!["repo:admin".into(), "user:read".into(), "checks:write".into()],

            site: true,

            token: "site token".into(),

        });

            Ok(Caller { account, scopes: tok.scope_list().iter().map(|s| s.to_string()).collect(), site: false, token: tok.name.clone() })

/// `GET /repos/{o}/{n}/proposals?state=open|draft|landed|closed|all`:

/// open ones (drafts too) by default.

    Query(q): Query<IssuesQuery>,

    let states: &[&str] = match q.state.as_deref().unwrap_or("open") {

        "open" => &["open", "draft"],

        "draft" => &["draft"],

        "landed" => &["landed"],

        "closed" => &["closed"],

        "all" => &["open", "draft", "landed", "closed"],

        other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state is open, draft, landed, closed or all, not {other:?}"))),

    };

    for p in db::proposals::list(&app.db, row.id, states).await? {

    let via = format!("api (token {})", c.token);

    match crate::web::proposals::land_as(&app, &repo, &row, &me, number, &via).await {

    pub landed_by: String,

    pub landed_via: String,

    pub landed_ms: i64,

    Ok(())

}

/// Mark a proposal landed, with who landed it and how.

pub async fn set_landed(pool: &Pool, id: i64, landed_state: &str, by: &str, via: &str) -> sqlx::Result<()> {

    let now = now_ms();

    sqlx::query(

        "UPDATE proposals SET state = 'landed', landed_state = ?, landed_by = ?, landed_via = ?, landed_ms = ?, updated_ms = ? WHERE id = ?",

    )

    .bind(landed_state)

    .bind(by)

    .bind(via)

    .bind(now)

    .bind(now)

    .bind(id)

    .execute(pool)

    .await?;

/// A proposal's source: a bookmark of this repository by name (which may

/// hold `/`, as `feature/16-hud` does), or `owner/name:bookmark` of a fork;

/// `owner/name:bookmark` naming this repository is its own bookmark.

    let plain = |b: &str| !b.is_empty() && !b.chars().any(|c| c.is_control() || c == ':');

        if !plain(bookmark) {

        }

        if fork == *repo {

            return Some((None, bookmark.to_string()));

        if !app.repos.exists(&fork) {

            return None;

        }

    plain(source).then(|| (None, source.to_string()))

    if fork.is_none() && !bookmarks.contains(&bookmark) {

        return Err(format!("There is no bookmark {bookmark} in this repository."));

    }

            // A landed proposal's changes are in its target now: it shows

            // the ones it landed, as recorded when it landed.

            let (changes, hashes) = if r2.state == "landed" && p.hashes.is_empty() {

                let hashes: Vec<ChangeHash> = r2.projected_changes().iter().filter_map(|h| ChangeHash::from_hex(h)).collect();

                let labels = HashMap::new();

                let changes = hashes

                    .iter()

                    .filter_map(|h| Some(view::change_view_pub(r, h, &r.store().get_change_meta(h).ok()?, false, &labels)))

                    .collect();

                (changes, hashes)

            } else {

                (p.changes, p.hashes)

            };

                changes,

                hashes,

    // Remember the projection for the list, the API and other proposals'

    // stacking checks, while the proposal is open: a landed one keeps what

    // it landed.

    if !loaded.row.is_open() {

        return Ok(loaded);

    }

    // Only an open proposal can be held back.

    if !loaded.row.is_open() {

        return Ok(Verdict { reviews, approvals, blockers, depends_on: vec![], requirements });

    }

    match land_as(&app, &repo, &row, &me.account, number, "web").await {

/// then records, announces and audits the landing, saying how it was done

/// (`via`: `web`, or `api (token NAME)`). Returns the new state.

    via: &str,

    pdb::set_landed(&app.db, p.id, &state, &me.username, via).await.map_err(|e| refused(e.to_string()))?;

    let how = if v.approvals.is_empty() { format!("{via}, with no approval") } else { via.to_string() };

    pdb::add_event(&app.db, p.id, &me.username, "landed", &how).await.ok();

    accounts::audit(&app.db, Some(me), "proposal.landed", &format!("{owner}/{name}#{number}"), &how).await.ok();

            reason: format!("landed #{number} ({how})"),

        landed: (p.state == "landed" && p.landed_ms > 0).then(|| hub_api::Landed {

            by: p.landed_by.clone(),

            via: p.landed_via.clone(),

            when_ms: p.landed_ms,

        }),

    // A source bookmark with `/` in its name, as a feature/N-name workflow

    // makes them: by name, and as this repository's owner/name:bookmark.

    for (b, file) in [("feature/1-one", "c.txt"), ("feature/2-two", "d.txt")] {

        client.bookmark_create(b, Some(&[base])).unwrap();

        client.bookmark_switch(b, false).unwrap();

        write(work.path(), file, b"c\n");

        client.snapshot("t").unwrap();

        client.commit(b, &[]).unwrap();

        assert!(client.push_bookmark("origin", b, false).unwrap().iter().all(|r| r.ok));

    }

    for source in ["feature/1-one", "andy/demo:feature/2-two"] {

        let body = format!(r#"{{"title":"Slash","target":"main","source":"{source}"}}"#);

        let (st, v) = api(app, "POST", "/api/v1/repos/andy/demo/proposals", Some(&bob_rw), Some(&body)).await;

        assert_eq!(st, StatusCode::CREATED, "{source}: {v}");

        let n = v["number"].as_i64().unwrap();

        let page = call(app, "GET", &format!("/andy/demo/proposal/{n}"), None, None, None, None).await;

        assert_eq!(page.status, StatusCode::OK);

        assert!(page.body.contains("feature/"), "the page names its source");

    }

    let body = r#"{"title":"None","target":"main","source":"feature/3-none"}"#;

    let (st, v) = api(app, "POST", "/api/v1/repos/andy/demo/proposals", Some(&bob_rw), Some(body)).await;

    assert!(st.is_client_error() && v.to_string().contains("no bookmark feature/3-none"), "{st} {v}");

    // Nobody approved, and the repository requires no approval: the page says so and Land asks first.

    assert!(page.body.contains("settings</a> require none."), "{}", page.body);

    assert!(page.body.contains("without any approval?"), "{}", page.body);

    assert!(get(app, "/andy/demo/pushes", None).await.body.contains("landed #1 (web)"));

    // Landed, it still shows what it landed, by whom and how, and nothing holds it back.

    let api = send(app, "GET", "/api/v1/repos/andy/demo/proposals/1", None, None, Some("site")).await;

    let v: serde_json::Value = serde_json::from_str(&api.body).unwrap();

    assert_eq!(v["state"], "landed", "{}", api.body);

    assert_eq!(v["changes"][0]["hash"], feat.to_hex(), "{}", api.body);

    assert_eq!(v["blockers"], serde_json::json!([]), "{}", api.body);

    assert_eq!(v["landed"]["by"], "andy");

    assert_eq!(v["landed"]["via"], "web");

    let page = get(app, "/andy/demo/proposal/1", Some(&andy)).await;

    assert!(page.body.contains("by <a href=\"/andy\">andy</a>, web"), "{}", page.body);

    // Lists by state through the API.

    let list = |q: &'static str| async move {

        let r = send(app, "GET", &format!("/api/v1/repos/andy/demo/proposals{q}"), None, None, Some("site")).await;

        serde_json::from_str::<serde_json::Value>(&r.body).unwrap().as_array().unwrap().len()

    };

    assert_eq!(list("").await, 0, "open ones only by default");

    assert_eq!(list("?state=landed").await, 1);

    assert_eq!(list("?state=all").await, 1);

    /// Open proposals (or --state draft|landed|closed|all)

    List {

        #[arg(long, default_value = "open")]

        state: String,

    },

        ProposalCmd::List { state } => {

            let path = format!("{base}/proposals?state={state}");

                println!("{}", ui::dim(&format!("No {} proposals.", if state == "all" { "" } else { &state }).replace("  ", " ")));

| `oh proposal list [--state open\|draft\|landed\|closed\|all]`, `oh proposal view N` | Proposals, with changes, approvals and blockers; a landed one with who landed it and how |

JSON under `/api/v1`, bearer tokens, `application/json`, RFC 7807 problem responses (an unknown route too), cursor pagination (`?after=`), ETags on cacheable resources, and rate limits per token. Resources mirror the pages: `/repos/{owner}/{name}`, `/bookmarks`, `/changes/{hash}`, `/tree/{ref}/{path}`, `/file/{ref}/{path}`, `/blame`, `/history`, `/compare`, `/conflicts`, `/proposals` (`?state=open|draft|landed|closed|all`, open ones and drafts by default; a source bookmark may hold `/`, and `owner/name:bookmark` naming the repository itself is its own bookmark), `/proposals/{n}/comments|reviews|checks|files`, `POST /proposals/{n}/land` (repo:write: what the Land button does, `409` with the blockers when it cannot; a landed proposal keeps the changes it landed and reports `landed` with who, how (`web`, or `api (token NAME)`) and when, which its event, the audit log and the push record also say, adding when nobody approved), `/proposals/{n}/content/{base|head}/{path}` (a changed file's bytes in the target's state or the projected state, for editor diff views), `/issues` (creating an issue can set its labels, assignees and milestone; `PATCH /issues/{n}` edits the title and body for the author or triage, and replaces labels, assignees or the milestone for triage, recording each on the timeline; unknown names are refused before anything changes), `/labels` (`POST` creates or changes one, `DELETE /labels/{name}` removes it; triage), `/milestones`, `/releases`, `/tags`, `/trust`, `/pushes`, `/hooks`, `/checks`, `/user`, `/notifications` (the caller's inbox and unread count; `/notifications/{id}/read` and `/notifications/read` mark read; scope `user:read`), `/users/{name}`, `/orgs/{name}`, `/checks/{state}` (the checks on a state, named by its hash, by its heads joined with `+`, by the one head of a single-head state, or by a bookmark), `/checks/required` (`GET`, and `PUT` of the whole list by a repository admin: the checks a proposal needs, passed, to land), `/projects/{owner}` (list, create) and `/projects/{owner}/{n}` (the board as the caller may see it, `PATCH` for title, description, privacy and closing, `/cards` to add a reference or note to a column named by id or name, `/cards/{id}` to move or remove one; `repo:write` and the page's rights to change), `/flow/runs` (`GET`: runs newest first, `?before=N&limit=`; `POST {"bookmark"}` or `{"change"}`, repo:write: run a bookmark's current state, the default bookmark when none is named, or one change's state), `/flow/runs/{n}` (a run with its jobs), `/flow/runs/{n}/jobs/{job}/log` (`?after=seq&limit=`) and `/flow/runs/{n}/rerun` (repo:write: a finished run again), both answering `201 {"number", "url"}` or `409` with why nothing started, `/search`. A change's author carries the account its key is linked to, or `null` and a `note` saying the key is not linked and where its owner links it (the change page shows a "key not linked" tag, with a link to Settings → Keys for signed-in viewers). Shapes reuse `oxy --json` shapes wherever one exists (change, status, blame, diff) so tools written against the CLI work against the hub. `crates/hub-api` holds the types with `serde` derives and is what the runner and the VS Code extension will link.

  {% if !p.landed_by.is_empty() %}<p class="small mute">by <a href="/{{ p.landed_by }}">{{ p.landed_by }}</a>, {{ p.landed_via }}, {{ p.landed_ms|ago }}</p>{% endif %}

    {% if blockers.is_empty() %}<p><span class="sig sig-valid">✔</span> ready to land</p>

    {% if requirements.required_approvals == 0 && approvals.is_empty() %}<p class="small warn-text">No approval yet, and this repository's <a href="{{ repo.url }}/settings">settings</a> require none.</p>{% endif %}

    {% else %}<ul class="plain small">{% for b in blockers %}<li><span class="sig sig-invalid">✘</span> {{ b }}</li>{% endfor %}</ul>{% endif %}

      {% if hub_can_land %}<form method="post" action="{{ repo.url }}/proposal/{{ p.number }}/land"{% if approvals.is_empty() %} onsubmit="return confirm('Land #{{ p.number }} without any approval?')"{% endif %}><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><button type="submit">LAND</button></form>

.warn-text { color: var(--warn); }