Skip to content
Sign in

flagon-io/g1t

public
0

g1t/services/work/src/rows.rs

379 lines12,716 bytesCodeBlame
1//! Rows as they come out of D1, and their conversion to contract types.
2
3use g1t_contracts::User;
4use g1t_contracts::repos::RepoPath;
5use g1t_contracts::work::{
6 CheckStatus, Comment, CommentKind, Issue, IssueReason, MilestoneRef, Pull, PullStatus, Runtime, SessionEntry,
7 SessionEntryKind, State, Verdict,
8};
9use serde::Deserialize;
10
11/// An author or actor as stored: g1t itself when the id is its own (a
12/// security update it opened, a merge its settings made), g1t's agent by
13/// its id (what it made or filed), a person otherwise.
14pub(crate) fn user(id: String, username: String) -> User {
15 let kind = if g1t_contracts::system::is_system_id(&id) {
16 g1t_contracts::PrincipalKind::System
17 } else if id == g1t_contracts::identity::AGENT_ID {
18 g1t_contracts::PrincipalKind::Agent
19 } else {
20 g1t_contracts::PrincipalKind::User
21 };
22 User {
23 id,
24 username,
25 kind,
26 ..User::default()
27 }
28}
29
30/// Who asked g1t for the work, as stored beside its author: both columns,
31/// or nobody.
32pub(crate) fn requester(id: Option<String>, username: Option<String>) -> Option<User> {
33 Some(user(id?, username?))
34}
35
36#[derive(Deserialize)]
37pub struct IssueRow {
38 pub id: String,
39 pub repo_id: String,
40 pub number: u32,
41 pub title: String,
42 pub body: String,
43 /// JSON array of label names.
44 pub labels: String,
45 pub state: State,
46 pub reason: Option<IssueReason>,
47 pub resolved_by: Option<u32>,
48 pub author_id: String,
49 pub author_name: String,
50 #[serde(default)]
51 pub requested_by_id: Option<String>,
52 #[serde(default)]
53 pub requested_by_name: Option<String>,
54 pub created_at: String,
55 pub updated_at: String,
56 pub closed_at: Option<String>,
57 pub pull_count: u32,
58 pub comment_count: u32,
59 /// JSON array of usernames.
60 pub assignees: String,
61 /// JSON array of issue numbers.
62 pub blocked_by: String,
63 /// JSON of who queued it for a g1t agent, if anyone has.
64 pub queued_by: Option<String>,
65 pub agent: Option<String>,
66 /// The number of its milestone, and that milestone's title.
67 #[serde(default)]
68 pub milestone: Option<u32>,
69 #[serde(default)]
70 pub milestone_title: Option<String>,
71}
72
73/// A milestone as an issue or pull request names it, from its number and
74/// title as read beside it.
75pub(crate) fn milestone_ref(number: Option<u32>, title: Option<String>) -> Option<MilestoneRef> {
76 Some(MilestoneRef { number: number?, title: title? })
77}
78
79impl From<IssueRow> for Issue {
80 fn from(row: IssueRow) -> Self {
81 Issue {
82 id: row.id,
83 repo_id: row.repo_id,
84 number: row.number,
85 title: row.title,
86 body: row.body,
87 labels: serde_json::from_str(&row.labels).unwrap_or_default(),
88 state: row.state,
89 reason: row.reason,
90 resolved_by: row.resolved_by,
91 author: user(row.author_id, row.author_name),
92 requested_by: requester(row.requested_by_id, row.requested_by_name),
93 created_at: row.created_at,
94 updated_at: row.updated_at,
95 closed_at: row.closed_at,
96 pull_count: row.pull_count,
97 comment_count: row.comment_count,
98 assignees: serde_json::from_str(&row.assignees).unwrap_or_default(),
99 blocked_by: serde_json::from_str(&row.blocked_by).unwrap_or_default(),
100 queued: row.queued_by.is_some(),
101 agent: row.agent,
102 milestone: milestone_ref(row.milestone, row.milestone_title),
103 }
104 }
105}
106
107/// The remembered assessment of a pull request, read beside its row.
108#[derive(Deserialize)]
109pub struct Snapshot {
110 pub stage: Option<g1t_contracts::work::Stage>,
111 pub stage_detail: Option<String>,
112 #[serde(default)]
113 pub revisions: u32,
114 /// Whether g1t is seeing it through at all.
115 #[serde(default)]
116 pub managed: u32,
117}
118
119/// A pull request's columns, with its confidence (confidence.rs) beside
120/// them: what every read of a [`PullRow`] selects.
121pub const PULL_COLUMNS: &str = "pulls.*,
122 (SELECT detail FROM pull_confidence WHERE pull_confidence.pull_id = pulls.id) AS confidence,
123 (SELECT title FROM milestones
124 WHERE milestones.repo_id = pulls.repo_id AND milestones.number = pulls.milestone) AS milestone_title";
125
126#[derive(Deserialize)]
127pub struct PullRow {
128 pub id: String,
129 pub repo_id: String,
130 pub number: u32,
131 pub issue_number: Option<u32>,
132 pub title: String,
133 pub body: Option<String>,
134 pub agent: String,
135 pub runtime: Runtime,
136 pub status: PullStatus,
137 pub fork_repo_id: Option<String>,
138 pub fork_namespace: Option<String>,
139 pub fork_name: Option<String>,
140 pub source_branch: Option<String>,
141 pub head_commit: Option<String>,
142 pub merge_base: Option<String>,
143 pub merged_by: Option<String>,
144 pub merged_at: Option<String>,
145 pub superseded_by: Option<u32>,
146 pub check_status: Option<CheckStatus>,
147 /// JSON array of changed files; `None` until first worked out.
148 pub files: Option<String>,
149 /// JSON arrays of usernames.
150 pub assignees: String,
151 pub reviewers: String,
152 /// JSON array of `workspace/team`.
153 #[serde(default)]
154 pub team_reviewers: Option<String>,
155 pub author_id: String,
156 pub author_name: String,
157 #[serde(default)]
158 pub requested_by_id: Option<String>,
159 #[serde(default)]
160 pub requested_by_name: Option<String>,
161 pub created_at: String,
162 pub updated_at: String,
163 /// JSON of its confidence, once worked out.
164 #[serde(default)]
165 pub confidence: Option<String>,
166 /// JSON array of label names.
167 #[serde(default)]
168 pub labels: Option<String>,
169 #[serde(default)]
170 pub milestone: Option<u32>,
171 #[serde(default)]
172 pub milestone_title: Option<String>,
173 /// The branch it merges into; NULL for the default branch.
174 #[serde(default)]
175 pub base_branch: Option<String>,
176 #[serde(default)]
177 pub head_pushed_by: Option<String>,
178 #[serde(default)]
179 pub head_pushed_at: Option<String>,
180}
181
182impl From<PullRow> for Pull {
183 fn from(row: PullRow) -> Self {
184 Pull {
185 id: row.id,
186 repo_id: row.repo_id,
187 number: row.number,
188 issue: row.issue_number,
189 title: row.title,
190 body: row.body,
191 agent: row.agent,
192 runtime: row.runtime,
193 status: row.status,
194 fork: row
195 .fork_namespace
196 .zip(row.fork_name)
197 .map(|(namespace, name)| RepoPath { namespace, name }),
198 fork_repo_id: row.fork_repo_id,
199 branch: row.source_branch,
200 head_commit: row.head_commit,
201 merge_base: row.merge_base,
202 merged_by: row.merged_by,
203 merged_at: row.merged_at,
204 superseded_by: row.superseded_by,
205 check_status: row.check_status,
206 files: row
207 .files
208 .as_deref()
209 .and_then(|files| serde_json::from_str(files).ok())
210 .unwrap_or_default(),
211 assignees: serde_json::from_str(&row.assignees).unwrap_or_default(),
212 reviewers: serde_json::from_str(&row.reviewers).unwrap_or_default(),
213 team_reviewers: row
214 .team_reviewers
215 .as_deref()
216 .and_then(|teams| serde_json::from_str(teams).ok())
217 .unwrap_or_default(),
218 author: user(row.author_id, row.author_name),
219 requested_by: requester(row.requested_by_id, row.requested_by_name),
220 created_at: row.created_at,
221 updated_at: row.updated_at,
222 confidence: row
223 .confidence
224 .as_deref()
225 .and_then(|detail| serde_json::from_str(detail).ok()),
226 labels: row
227 .labels
228 .as_deref()
229 .and_then(|labels| serde_json::from_str(labels).ok())
230 .unwrap_or_default(),
231 milestone: milestone_ref(row.milestone, row.milestone_title),
232 base: row.base_branch,
233 head_pushed_by: row.head_pushed_by,
234 head_pushed_at: row.head_pushed_at,
235 }
236 }
237}
238
239#[derive(Deserialize)]
240pub struct CommentRow {
241 pub id: String,
242 pub kind: CommentKind,
243 pub author_id: String,
244 pub author_name: String,
245 pub body: String,
246 pub path: Option<String>,
247 pub line: Option<u32>,
248 pub verdict: Option<Verdict>,
249 pub created_at: String,
250}
251
252impl From<CommentRow> for Comment {
253 fn from(row: CommentRow) -> Self {
254 Comment {
255 id: row.id,
256 kind: row.kind,
257 author: user(row.author_id, row.author_name),
258 body: row.body,
259 path: row.path,
260 line: row.line,
261 verdict: row.verdict,
262 created_at: row.created_at,
263 }
264 }
265}
266
267#[derive(Deserialize)]
268pub struct SessionRow {
269 pub seq: u32,
270 pub kind: SessionEntryKind,
271 pub text: String,
272 pub tool: Option<String>,
273 pub commit: Option<String>,
274 pub at: String,
275}
276
277impl From<SessionRow> for SessionEntry {
278 fn from(row: SessionRow) -> Self {
279 SessionEntry {
280 seq: row.seq,
281 kind: row.kind,
282 text: row.text,
283 tool: row.tool,
284 commit: row.commit,
285 at: row.at,
286 }
287 }
288}
289
290/// A pull request whose head a push moved.
291#[derive(Deserialize)]
292pub struct MovedRow {
293 pub id: String,
294 pub repo_id: String,
295 pub number: u32,
296 pub issue_number: Option<u32>,
297 pub status: PullStatus,
298 pub author_id: String,
299 pub author_name: String,
300 #[serde(default)]
301 pub requested_by_id: Option<String>,
302 #[serde(default)]
303 pub requested_by_name: Option<String>,
304}
305
306/// A single number selected as `n`.
307#[derive(Deserialize)]
308pub struct NumberRow {
309 pub n: u32,
310}
311
312/// A single string selected as `value`.
313#[derive(Deserialize)]
314pub struct ValueRow {
315 pub value: String,
316}
317
318/// Rows as the database holds them, for tests of the rules that read them.
319#[cfg(test)]
320pub(crate) mod stored {
321 use super::*;
322
323 /// A pull request g1t made in a fork, read back as stored: g1t as its
324 /// author, and `requested_by` the person who asked, if anyone did.
325 pub(crate) fn pull(author: (&str, &str), requested_by: Option<(&str, &str)>) -> Pull {
326 let row: PullRow = serde_json::from_value(serde_json::json!({
327 "id": "pr_1", "repo_id": "rep_1", "number": 14, "issue_number": 12, "title": "Fix it",
328 "body": null, "agent": "g1t", "runtime": "hosted", "status": "open",
329 "fork_repo_id": "rep_f", "fork_namespace": "pulls", "fork_name": "pr_1",
330 "source_branch": null, "head_commit": null, "merge_base": null, "merged_by": null,
331 "merged_at": null, "superseded_by": null, "check_status": null, "files": null,
332 "assignees": "[]", "reviewers": "[]",
333 "author_id": author.0, "author_name": author.1,
334 "requested_by_id": requested_by.map(|(id, _)| id),
335 "requested_by_name": requested_by.map(|(_, name)| name),
336 "created_at": "", "updated_at": ""
337 }))
338 .unwrap();
339 row.into()
340 }
341
342 /// g1t's agent, as an author is stored.
343 pub(crate) const G1T: (&str, &str) = (g1t_contracts::identity::AGENT_ID, "g1t");
344 /// The person who asked g1t for the work.
345 pub(crate) const ASKER: (&str, &str) = ("usr_1", "syntaqx");
346}
347
348#[cfg(test)]
349mod tests {
350 use super::stored::{ASKER, G1T, pull};
351 use super::*;
352 use g1t_contracts::PrincipalKind;
353
354 #[test]
355 fn g1t_s_pull_request_reads_back_as_g1t_s_requested_by_the_person() {
356 let made = pull(G1T, Some(ASKER));
357 assert_eq!((made.author.username.as_str(), made.author.kind), ("g1t", PrincipalKind::Agent));
358 let asked = made.requested_by.as_ref().expect("who asked is kept");
359 assert_eq!((asked.id.as_str(), asked.username.as_str(), asked.kind), ("usr_1", "syntaqx", PrincipalKind::User));
360 assert_eq!(made.owner().id, "usr_1");
361 }
362
363 #[test]
364 fn anyone_else_s_reads_back_as_theirs_alone() {
365 let own = pull(ASKER, None);
366 assert_eq!(own.author.kind, PrincipalKind::User);
367 assert!(own.requested_by.is_none());
368 assert_eq!(own.owner().id, "usr_1");
369 // Half a requester is nobody.
370 assert!(requester(Some("usr_1".into()), None).is_none());
371 }
372
373 #[test]
374 fn g1t_s_own_work_reads_back_as_g1t_itself() {
375 let own = pull(("g1t", "g1t"), None);
376 assert_eq!(own.author.kind, PrincipalKind::System);
377 assert!(own.requested_by.is_none());
378 }
379}