activity.rs 91.2%

125 of 137 lines run, 19 of 44 functions · run #517 on main · run missed

//! Cross-repository reads for the signed-in dashboard (hub spec §6):
//! the activity feed and the proposals waiting on a reviewer. Callers
//! pass the repository ids the viewer may see, so nothing here decides
//! access.

use super::Pool;
use sqlx::FromRow;

/// One line of the activity feed.
#[derive(Clone, Debug, FromRow)]
pub struct Activity {
    pub owner: String,
    pub name: String,
    pub at_ms: i64,
    pub actor: String,
    /// `push`, `release`, `proposal` or `issue`.
    pub kind: String,
    /// What happened: the event name, or the bookmark for a push.
    pub event: String,
    /// The proposal or issue title, the release tag.
    pub title: String,
    /// The proposal or issue number, 0 otherwise.
    pub number: i64,
}

impl Activity {
    /// Where the line links to.
    pub fn url(&self) -> String {
        let base = format!("/{}/{}", self.owner, self.name);
        match self.kind.as_str() {
            "proposal" => format!("{base}/proposal/{}", self.number),
            "issue" => format!("{base}/issue/{}", self.number),
            "release" => format!("{base}/releases/tag/{}", self.title),
            _ => format!("{base}/pushes"),
        }
    }
}

fn ids_json(ids: &[i64]) -> String {
    serde_json::to_string(ids).unwrap_or_else(|_| "[]".into())
}

/// The SQL with each `SELECT value FROM json_each($n)` (the ids bound as a
/// JSON array) in this engine's words: Postgres has `json_array_elements_text`.
fn each(sql: &'static str) -> std::borrow::Cow<'static, str> {
    if cfg!(feature = "postgres") {
        let mut out = sql.to_string();
        for n in 1..=4 {
            out = out.replace(
                &format!("SELECT value FROM json_each(${n})"),
                &format!("SELECT CAST(value AS BIGINT) FROM json_array_elements_text(CAST(${n} AS json)) AS t(value)"),
            );
        }
        out.into()
    } else {
        sql.into()
    }
}

/// The newest `limit` events across the repositories in `repo_ids`.
pub async fn feed(pool: &Pool, repo_ids: &[i64], limit: i64) -> sqlx::Result<Vec<Activity>> {
    feed_by(pool, repo_ids, None, limit).await
}

/// Like `feed`, only what `actor` did when one is given (profile pages).
pub async fn feed_by(pool: &Pool, repo_ids: &[i64], actor: Option<&str>, limit: i64) -> sqlx::Result<Vec<Activity>> {
    sqlx::query_as(
        &each("WITH seen(id) AS (SELECT value FROM json_each($1)), ev AS ( \
           SELECT repo_id, at_ms, pusher AS actor, 'push' AS kind, reference AS event, '' AS title, 0 AS number FROM pushes WHERE ok = TRUE \
           UNION ALL SELECT repo_id, created_ms, author, 'release', 'published', tag, 0 FROM releases \
           UNION ALL SELECT p.repo_id, e.at_ms, e.actor, 'proposal', e.event, p.title, p.number FROM proposal_events e JOIN proposals p ON p.id = e.proposal_id \
           UNION ALL SELECT i.repo_id, e.at_ms, e.actor, 'issue', e.event, i.title, i.number FROM issue_events e JOIN issues i ON i.id = e.issue_id) \
         SELECT r.owner, r.name, ev.at_ms, ev.actor, ev.kind, ev.event, ev.title, ev.number \
         FROM ev JOIN repositories r ON r.id = ev.repo_id WHERE ev.repo_id IN (SELECT id FROM seen) \
           AND ($2 IS NULL OR lower(ev.actor) = lower($3)) \
         ORDER BY ev.at_ms DESC LIMIT $4"),
    )
    .bind(ids_json(repo_ids))
    .bind(actor)
    .bind(actor)
    .bind(limit)
    .fetch_all(pool)
    .await
}

/// A proposal on the dashboard, with its repository's name.
#[derive(Clone, Debug, FromRow)]
pub struct ProposalLine {
    pub owner: String,
    pub name: String,
    pub number: i64,
    pub title: String,
    pub author: String,
    pub state: String,
    pub conflicted: bool,
    pub updated_ms: i64,
}

/// Open proposals in `repo_ids` by someone else that `account_id` has
/// not reviewed yet: the review queue.
pub async fn awaiting_review(pool: &Pool, account_id: i64, repo_ids: &[i64]) -> sqlx::Result<Vec<ProposalLine>> {
    sqlx::query_as(&each(
        "SELECT r.owner, r.name, p.number, p.title, p.author, p.state, p.conflicted, p.updated_ms \
         FROM proposals p JOIN repositories r ON r.id = p.repo_id \
         WHERE p.repo_id IN (SELECT value FROM json_each($1)) AND p.state = 'open' \
           AND (p.author_id IS NULL OR p.author_id != $2) \
           AND NOT EXISTS (SELECT 1 FROM proposal_reviews v WHERE v.proposal_id = p.id AND v.author_id = $3) \
         ORDER BY p.updated_ms DESC",
    ))
    .bind(ids_json(repo_ids))
    .bind(account_id)
    .bind(account_id)
    .fetch_all(pool)
    .await
}

/// `account_id`'s own open and draft proposals in repositories it can
/// still see.
pub async fn authored(pool: &Pool, account_id: i64, repo_ids: &[i64]) -> sqlx::Result<Vec<ProposalLine>> {
    sqlx::query_as(&each(
        "SELECT r.owner, r.name, p.number, p.title, p.author, p.state, p.conflicted, p.updated_ms \
         FROM proposals p JOIN repositories r ON r.id = p.repo_id \
         WHERE p.author_id = $1 AND p.state IN ('open', 'draft') AND p.repo_id IN (SELECT value FROM json_each($2)) \
         ORDER BY p.updated_ms DESC",
    ))
    .bind(account_id)
    .bind(ids_json(repo_ids))
    .fetch_all(pool)
    .await
}

/// An issue on the dashboard, with its repository's name.
#[derive(Clone, Debug, FromRow)]
pub struct IssueLine {
    pub owner: String,
    pub name: String,
    pub number: i64,
    pub title: String,
    pub updated_ms: i64,
}

/// Open issues assigned to `account_id`, in repositories it can see.
pub async fn assigned(pool: &Pool, account_id: i64, repo_ids: &[i64]) -> sqlx::Result<Vec<IssueLine>> {
    sqlx::query_as(&each(
        "SELECT r.owner, r.name, i.number, i.title, i.updated_ms \
         FROM issues i JOIN issue_assignees a ON a.issue_id = i.id JOIN repositories r ON r.id = i.repo_id \
         WHERE a.account_id = $1 AND i.state = 'open' AND i.repo_id IN (SELECT value FROM json_each($2)) \
         ORDER BY i.updated_ms DESC",
    ))
    .bind(account_id)
    .bind(ids_json(repo_ids))
    .fetch_all(pool)
    .await
}

/// One event of Your sky (docs/backgrounds.md §5): its repository, when,
/// its kind (0 a push, 1 a proposal event, 2 an issue event, 3 a release,
/// 4 a Flow run) and how many marks it makes: a push's changes, else one.
#[derive(Clone, Debug, FromRow)]
pub struct SkyEvent {
    pub repo_id: i64,
    pub at_ms: i64,
    pub kind: i64,
    pub n: i64,
}

/// The events since `since_ms` in `repo_ids`, newest first, at most `limit`.
pub async fn sky(pool: &Pool, repo_ids: &[i64], since_ms: i64, limit: i64) -> sqlx::Result<Vec<SkyEvent>> {
    sqlx::query_as(
        &each("WITH seen(id) AS (SELECT value FROM json_each($1)), ev AS ( \
           SELECT repo_id, at_ms, CAST(0 AS BIGINT) AS kind, CASE WHEN changes > 1 THEN changes ELSE 1 END AS n FROM pushes WHERE ok = TRUE \
           UNION ALL SELECT p.repo_id, e.at_ms, 1, 1 FROM proposal_events e JOIN proposals p ON p.id = e.proposal_id \
           UNION ALL SELECT i.repo_id, e.at_ms, 2, 1 FROM issue_events e JOIN issues i ON i.id = e.issue_id \
           UNION ALL SELECT repo_id, created_ms, 3, 1 FROM releases \
           UNION ALL SELECT repo_id, created_ms, 4, 1 FROM flow_runs) \
         SELECT repo_id, at_ms, kind, n FROM ev WHERE repo_id IN (SELECT id FROM seen) AND at_ms >= $2 \
         ORDER BY at_ms DESC LIMIT $3"),
    )
    .bind(ids_json(repo_ids))
    .bind(since_ms)
    .bind(limit)
    .fetch_all(pool)
    .await
}

/// One account's pushes of the last year in the repositories a viewer may
/// see, for the profile's pulse (#217): `(repo_id, at_ms, changes, via)`.
/// Landings are left out (their changes were pushed once already), as are
/// failed pushes and pushes that brought nothing.
pub async fn pulse(pool: &Pool, account_id: i64, repo_ids: &[i64], since_ms: i64) -> sqlx::Result<Vec<(i64, i64, i64, String)>> {
    let ids = serde_json::to_string(repo_ids).unwrap_or_else(|_| "[]".into());
    sqlx::query_as(&each(
        "SELECT repo_id, at_ms, changes, via FROM pushes \
         WHERE account_id = $1 AND ok = TRUE AND changes > 0 AND at_ms >= $2 AND reason NOT LIKE 'landed%' \
           AND repo_id IN (SELECT value FROM json_each($3)) ORDER BY at_ms",
    ))
    .bind(account_id)
    .bind(since_ms)
    .bind(ids)
    .fetch_all(pool)
    .await
}

/// Releases an account made in the last year in repositories a viewer may
/// see: `(repo_id, tag, created_ms)`, to label the pulse's peaks.
pub async fn releases_by(pool: &Pool, account_id: i64, repo_ids: &[i64], since_ms: i64) -> sqlx::Result<Vec<(i64, String, i64)>> {
    let ids = serde_json::to_string(repo_ids).unwrap_or_else(|_| "[]".into());
    sqlx::query_as(&each(
        "SELECT repo_id, tag, created_ms FROM releases WHERE author_id = $1 AND created_ms >= $2 \
           AND repo_id IN (SELECT value FROM json_each($3)) ORDER BY created_ms",
    ))
    .bind(account_id)
    .bind(since_ms)
    .bind(ids)
    .fetch_all(pool)
    .await
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Cross-repository reads for the signed-in dashboard (hub spec §6):
2		//! the activity feed and the proposals waiting on a reviewer. Callers
3		//! pass the repository ids the viewer may see, so nothing here decides
4		//! access.
5
6		use super::Pool;
7		use sqlx::FromRow;
8
9		/// One line of the activity feed.
10		#[derive(Clone, Debug, FromRow)]
11		pub struct Activity {
12		pub owner: String,
13		pub name: String,
14		pub at_ms: i64,
15		pub actor: String,
16		/// `push`, `release`, `proposal` or `issue`.
17		pub kind: String,
18		/// What happened: the event name, or the bookmark for a push.
19		pub event: String,
20		/// The proposal or issue title, the release tag.
21		pub title: String,
22		/// The proposal or issue number, 0 otherwise.
23		pub number: i64,
24		}
25
26		impl Activity {
27		/// Where the line links to.
28	8×	pub fn url(&self) -> String {
29	8×	let base = format!("/{}/{}", self.owner, self.name);
30	8×	match self.kind.as_str() {
31	8×	"proposal" => format!("{base}/proposal/{}", self.number),
32	1×	"issue" => format!("{base}/issue/{}", self.number),
33	1×	"release" => format!("{base}/releases/tag/{}", self.title),
34	0×	_ => format!("{base}/pushes"),
35		}
36	8×	}
37		}
38
39	231×	fn ids_json(ids: &[i64]) -> String {
40	231×	serde_json::to_string(ids).unwrap_or_else(\|_\| "[]".into())
41	231×	}
42
43		/// The SQL with each `SELECT value FROM json_each($n)` (the ids bound as a
44		/// JSON array) in this engine's words: Postgres has `json_array_elements_text`.
45	253×	fn each(sql: &'static str) -> std::borrow::Cow<'static, str> {
46	253×	if cfg!(feature = "postgres") {
47	0×	let mut out = sql.to_string();
48	0×	for n in 1..=4 {
49	0×	out = out.replace(
50	0×	&format!("SELECT value FROM json_each(${n})"),
51	0×	&format!("SELECT CAST(value AS BIGINT) FROM json_array_elements_text(CAST(${n} AS json)) AS t(value)"),
52	0×	);
53	0×	}
54	0×	out.into()
55		} else {
56	253×	sql.into()
57		}
58	253×	}
59
60		/// The newest `limit` events across the repositories in `repo_ids`.
61	10×	pub async fn feed(pool: &Pool, repo_ids: &[i64], limit: i64) -> sqlx::Result<Vec<Activity>> {
62	10×	feed_by(pool, repo_ids, None, limit).await
63	10×	}
64
65		/// Like `feed`, only what `actor` did when one is given (profile pages).
66	21×	pub async fn feed_by(pool: &Pool, repo_ids: &[i64], actor: Option<&str>, limit: i64) -> sqlx::Result<Vec<Activity>> {
67	21×	sqlx::query_as(
68	21×	&each("WITH seen(id) AS (SELECT value FROM json_each($1)), ev AS ( \
69	21×	SELECT repo_id, at_ms, pusher AS actor, 'push' AS kind, reference AS event, '' AS title, 0 AS number FROM pushes WHERE ok = TRUE \
70	21×	UNION ALL SELECT repo_id, created_ms, author, 'release', 'published', tag, 0 FROM releases \
71	21×	UNION ALL SELECT p.repo_id, e.at_ms, e.actor, 'proposal', e.event, p.title, p.number FROM proposal_events e JOIN proposals p ON p.id = e.proposal_id \
72	21×	UNION ALL SELECT i.repo_id, e.at_ms, e.actor, 'issue', e.event, i.title, i.number FROM issue_events e JOIN issues i ON i.id = e.issue_id) \
73	21×	SELECT r.owner, r.name, ev.at_ms, ev.actor, ev.kind, ev.event, ev.title, ev.number \
74	21×	FROM ev JOIN repositories r ON r.id = ev.repo_id WHERE ev.repo_id IN (SELECT id FROM seen) \
75	21×	AND ($2 IS NULL OR lower(ev.actor) = lower($3)) \
76	21×	ORDER BY ev.at_ms DESC LIMIT $4"),
77	21×	)
78	21×	.bind(ids_json(repo_ids))
79	21×	.bind(actor)
80	21×	.bind(actor)
81	21×	.bind(limit)
82	21×	.fetch_all(pool)
83	21×	.await
84	21×	}
85
86		/// A proposal on the dashboard, with its repository's name.
87		#[derive(Clone, Debug, FromRow)]
88		pub struct ProposalLine {
89		pub owner: String,
90		pub name: String,
91		pub number: i64,
92		pub title: String,
93		pub author: String,
94		pub state: String,
95		pub conflicted: bool,
96		pub updated_ms: i64,
97		}
98
99		/// Open proposals in `repo_ids` by someone else that `account_id` has
100		/// not reviewed yet: the review queue.
101	13×	pub async fn awaiting_review(pool: &Pool, account_id: i64, repo_ids: &[i64]) -> sqlx::Result<Vec<ProposalLine>> {
102	13×	sqlx::query_as(&each(
103	13×	"SELECT r.owner, r.name, p.number, p.title, p.author, p.state, p.conflicted, p.updated_ms \
104	13×	FROM proposals p JOIN repositories r ON r.id = p.repo_id \
105	13×	WHERE p.repo_id IN (SELECT value FROM json_each($1)) AND p.state = 'open' \
106	13×	AND (p.author_id IS NULL OR p.author_id != $2) \
107	13×	AND NOT EXISTS (SELECT 1 FROM proposal_reviews v WHERE v.proposal_id = p.id AND v.author_id = $3) \
108	13×	ORDER BY p.updated_ms DESC",
109	13×	))
110	13×	.bind(ids_json(repo_ids))
111	13×	.bind(account_id)
112	13×	.bind(account_id)
113	13×	.fetch_all(pool)
114	13×	.await
115	13×	}
116
117		/// `account_id`'s own open and draft proposals in repositories it can
118		/// still see.
119	13×	pub async fn authored(pool: &Pool, account_id: i64, repo_ids: &[i64]) -> sqlx::Result<Vec<ProposalLine>> {
120	13×	sqlx::query_as(&each(
121	13×	"SELECT r.owner, r.name, p.number, p.title, p.author, p.state, p.conflicted, p.updated_ms \
122	13×	FROM proposals p JOIN repositories r ON r.id = p.repo_id \
123	13×	WHERE p.author_id = $1 AND p.state IN ('open', 'draft') AND p.repo_id IN (SELECT value FROM json_each($2)) \
124	13×	ORDER BY p.updated_ms DESC",
125	13×	))
126	13×	.bind(account_id)
127	13×	.bind(ids_json(repo_ids))
128	13×	.fetch_all(pool)
129	13×	.await
130	13×	}
131
132		/// An issue on the dashboard, with its repository's name.
133		#[derive(Clone, Debug, FromRow)]
134		pub struct IssueLine {
135		pub owner: String,
136		pub name: String,
137		pub number: i64,
138		pub title: String,
139		pub updated_ms: i64,
140		}
141
142		/// Open issues assigned to `account_id`, in repositories it can see.
143	8×	pub async fn assigned(pool: &Pool, account_id: i64, repo_ids: &[i64]) -> sqlx::Result<Vec<IssueLine>> {
144	8×	sqlx::query_as(&each(
145	8×	"SELECT r.owner, r.name, i.number, i.title, i.updated_ms \
146	8×	FROM issues i JOIN issue_assignees a ON a.issue_id = i.id JOIN repositories r ON r.id = i.repo_id \
147	8×	WHERE a.account_id = $1 AND i.state = 'open' AND i.repo_id IN (SELECT value FROM json_each($2)) \
148	8×	ORDER BY i.updated_ms DESC",
149	8×	))
150	8×	.bind(account_id)
151	8×	.bind(ids_json(repo_ids))
152	8×	.fetch_all(pool)
153	8×	.await
154	8×	}
155
156		/// One event of Your sky (docs/backgrounds.md §5): its repository, when,
157		/// its kind (0 a push, 1 a proposal event, 2 an issue event, 3 a release,
158		/// 4 a Flow run) and how many marks it makes: a push's changes, else one.
159		#[derive(Clone, Debug, FromRow)]
160		pub struct SkyEvent {
161		pub repo_id: i64,
162		pub at_ms: i64,
163		pub kind: i64,
164		pub n: i64,
165		}
166
167		/// The events since `since_ms` in `repo_ids`, newest first, at most `limit`.
168	176×	pub async fn sky(pool: &Pool, repo_ids: &[i64], since_ms: i64, limit: i64) -> sqlx::Result<Vec<SkyEvent>> {
169	176×	sqlx::query_as(
170	176×	&each("WITH seen(id) AS (SELECT value FROM json_each($1)), ev AS ( \
171	176×	SELECT repo_id, at_ms, CAST(0 AS BIGINT) AS kind, CASE WHEN changes > 1 THEN changes ELSE 1 END AS n FROM pushes WHERE ok = TRUE \
172	176×	UNION ALL SELECT p.repo_id, e.at_ms, 1, 1 FROM proposal_events e JOIN proposals p ON p.id = e.proposal_id \
173	176×	UNION ALL SELECT i.repo_id, e.at_ms, 2, 1 FROM issue_events e JOIN issues i ON i.id = e.issue_id \
174	176×	UNION ALL SELECT repo_id, created_ms, 3, 1 FROM releases \
175	176×	UNION ALL SELECT repo_id, created_ms, 4, 1 FROM flow_runs) \
176	176×	SELECT repo_id, at_ms, kind, n FROM ev WHERE repo_id IN (SELECT id FROM seen) AND at_ms >= $2 \
177	176×	ORDER BY at_ms DESC LIMIT $3"),
178	176×	)
179	176×	.bind(ids_json(repo_ids))
180	176×	.bind(since_ms)
181	176×	.bind(limit)
182	176×	.fetch_all(pool)
183	176×	.await
184	176×	}
185
186		/// One account's pushes of the last year in the repositories a viewer may
187		/// see, for the profile's pulse (#217): `(repo_id, at_ms, changes, via)`.
188		/// Landings are left out (their changes were pushed once already), as are
189		/// failed pushes and pushes that brought nothing.
190	11×	pub async fn pulse(pool: &Pool, account_id: i64, repo_ids: &[i64], since_ms: i64) -> sqlx::Result<Vec<(i64, i64, i64, String)>> {
191	11×	let ids = serde_json::to_string(repo_ids).unwrap_or_else(\|_\| "[]".into());
192	11×	sqlx::query_as(&each(
193	11×	"SELECT repo_id, at_ms, changes, via FROM pushes \
194	11×	WHERE account_id = $1 AND ok = TRUE AND changes > 0 AND at_ms >= $2 AND reason NOT LIKE 'landed%' \
195	11×	AND repo_id IN (SELECT value FROM json_each($3)) ORDER BY at_ms",
196	11×	))
197	11×	.bind(account_id)
198	11×	.bind(since_ms)
199	11×	.bind(ids)
200	11×	.fetch_all(pool)
201	11×	.await
202	11×	}
203
204		/// Releases an account made in the last year in repositories a viewer may
205		/// see: `(repo_id, tag, created_ms)`, to label the pulse's peaks.
206	11×	pub async fn releases_by(pool: &Pool, account_id: i64, repo_ids: &[i64], since_ms: i64) -> sqlx::Result<Vec<(i64, String, i64)>> {
207	11×	let ids = serde_json::to_string(repo_ids).unwrap_or_else(\|_\| "[]".into());
208	11×	sqlx::query_as(&each(
209	11×	"SELECT repo_id, tag, created_ms FROM releases WHERE author_id = $1 AND created_ms >= $2 \
210	11×	AND repo_id IN (SELECT value FROM json_each($3)) ORDER BY created_ms",
211	11×	))
212	11×	.bind(account_id)
213	11×	.bind(since_ms)
214	11×	.bind(ids)
215	11×	.fetch_all(pool)
216	11×	.await
217	11×	}

Coverage / crates/hub/src/db/activity.rs 91.2%

Keyboard