wsb-daemon 0.291.8591

wsb's daemon: the workbench, the GitHub mirror's schedule and peer continuity, for every workspace on the host
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Issues: read from the workshop's mirror, written through GitHub.
//!
//! Every read answers from the mirror — instantly, offline, with no token —
//! and carries how current each repository's copy is. Refreshing is the
//! daemon keeping current what a page shows, or a button (`POST
//! /github/refresh`), never a side effect of a read.

use axum::{
    extract::{Path, Query, State},
    Json,
};
use serde::Deserialize;

use crate::web::github::{self, Refusal};
use crate::web::state::WebState;
use wsb_github::client::{CreateIssueRequest, GitHubComment, GitHubIssue, UpdateIssueRequest};
use wsb_github::service::IssueState;

#[derive(Deserialize)]
pub struct ListIssuesQuery {
    pub state: Option<String>,
    pub repo: Option<String>,
}

fn issue_state(query: &ListIssuesQuery) -> Result<IssueState, Refusal> {
    query
        .state
        .as_deref()
        .unwrap_or("open")
        .parse()
        .map_err(|error: String| github::failure(wsb_github::Failure::Invalid(error)))
}

/// GET /api/v1/issues — every mirrored issue of this worktree's repositories.
pub async fn list_issues(
    State(state): State<WebState>,
    Query(query): Query<ListIssuesQuery>,
) -> Result<Json<wsb_github::service::IssueList>, Refusal> {
    let wanted = issue_state(&query)?;
    let service = github::of(&state)?.service.clone();
    let mut repos = github::repository_names(&state).await?;
    if let Some(repo) = &query.repo {
        repos.retain(|held| held == repo);
    }
    github::blocking(move || service.issues(&repos, wanted))
        .await
        .map(Json)
}

/// GET /api/v1/issues/:owner/:repo — one repository's mirrored issues.
pub async fn list_repo_issues(
    State(state): State<WebState>,
    Path((owner, repo)): Path<(String, String)>,
    Query(query): Query<ListIssuesQuery>,
) -> Result<Json<serde_json::Value>, Refusal> {
    let wanted = issue_state(&query)?;
    let service = github::of(&state)?.service.clone();
    let name = format!("{owner}/{repo}");
    let repos = vec![name.clone()];
    let mut list = github::blocking(move || service.issues(&repos, wanted)).await?;
    Ok(Json(serde_json::json!({
        "repo": name,
        "issues": list.issues,
        "sync": list.sync.remove(&name),
    })))
}

/// POST /api/v1/issues/:owner/:repo
pub async fn create_issue(
    State(state): State<WebState>,
    Path((owner, repo)): Path<(String, String)>,
    Json(body): Json<CreateIssueRequest>,
) -> Result<Json<GitHubIssue>, Refusal> {
    let github = github::of(&state)?;
    let client = github::client(github)?;
    github
        .service
        .create_issue(&client, &owner, &repo, &body)
        .await
        .map(Json)
        .map_err(github::failure)
}

/// PATCH /api/v1/issues/:owner/:repo/:number
pub async fn update_issue(
    State(state): State<WebState>,
    Path((owner, repo, number)): Path<(String, String, i64)>,
    Json(body): Json<UpdateIssueRequest>,
) -> Result<Json<GitHubIssue>, Refusal> {
    let github = github::of(&state)?;
    let client = github::client(github)?;
    github
        .service
        .update_issue(&client, &owner, &repo, number, &body)
        .await
        .map(Json)
        .map_err(github::failure)
}

#[derive(Deserialize)]
pub struct CommentRequest {
    pub body: String,
}

/// GET /api/v1/issues/:owner/:repo/:number/comments
///
/// Opening a thread puts it in the sweep; the first open reads it now, when
/// there is a token to read with.
pub async fn list_comments(
    State(state): State<WebState>,
    Path((owner, repo, number)): Path<(String, String, i64)>,
) -> Result<Json<serde_json::Value>, Refusal> {
    let github = github::of(&state)?;
    let client = github::client(github).ok();
    let listed = github
        .service
        .comments(client.as_ref(), &format!("{owner}/{repo}"), number)
        .await
        .map_err(github::failure)?;
    Ok(Json(serde_json::json!({ "comments": listed.items, "sync": listed.sync })))
}

/// POST /api/v1/issues/:owner/:repo/:number/comments
pub async fn add_comment(
    State(state): State<WebState>,
    Path((owner, repo, number)): Path<(String, String, i64)>,
    Json(body): Json<CommentRequest>,
) -> Result<Json<GitHubComment>, Refusal> {
    let github = github::of(&state)?;
    let client = github::client(github)?;
    github
        .service
        .add_comment(&client, &owner, &repo, number, &body.body)
        .await
        .map(Json)
        .map_err(github::failure)
}