Skip to content
Sign in

flagon-io/g1t

public
0

g1t/services/work/src/rows.rs

373 lines12,496 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}
177
178impl From<PullRow> for Pull {
179 fn from(row: PullRow) -> Self {
180 Pull {
181 id: row.id,
182 repo_id: row.repo_id,
183 number: row.number,
184 issue: row.issue_number,
185 title: row.title,
186 body: row.body,
187 agent: row.agent,
188 runtime: row.runtime,
189 status: row.status,
190 fork: row
191 .fork_namespace
192 .zip(row.fork_name)
193 .map(|(namespace, name)| RepoPath { namespace, name }),
194 fork_repo_id: row.fork_repo_id,
195 branch: row.source_branch,
196 head_commit: row.head_commit,
197 merge_base: row.merge_base,
198 merged_by: row.merged_by,
199 merged_at: row.merged_at,
200 superseded_by: row.superseded_by,
201 check_status: row.check_status,
202 files: row
203 .files
204 .as_deref()
205 .and_then(|files| serde_json::from_str(files).ok())
206 .unwrap_or_default(),
207 assignees: serde_json::from_str(&row.assignees).unwrap_or_default(),
208 reviewers: serde_json::from_str(&row.reviewers).unwrap_or_default(),
209 team_reviewers: row
210 .team_reviewers
211 .as_deref()
212 .and_then(|teams| serde_json::from_str(teams).ok())
213 .unwrap_or_default(),
214 author: user(row.author_id, row.author_name),
215 requested_by: requester(row.requested_by_id, row.requested_by_name),
216 created_at: row.created_at,
217 updated_at: row.updated_at,
218 confidence: row
219 .confidence
220 .as_deref()
221 .and_then(|detail| serde_json::from_str(detail).ok()),
222 labels: row
223 .labels
224 .as_deref()
225 .and_then(|labels| serde_json::from_str(labels).ok())
226 .unwrap_or_default(),
227 milestone: milestone_ref(row.milestone, row.milestone_title),
228 base: row.base_branch,
229 }
230 }
231}
232
233#[derive(Deserialize)]
234pub struct CommentRow {
235 pub id: String,
236 pub kind: CommentKind,
237 pub author_id: String,
238 pub author_name: String,
239 pub body: String,
240 pub path: Option<String>,
241 pub line: Option<u32>,
242 pub verdict: Option<Verdict>,
243 pub created_at: String,
244}
245
246impl From<CommentRow> for Comment {
247 fn from(row: CommentRow) -> Self {
248 Comment {
249 id: row.id,
250 kind: row.kind,
251 author: user(row.author_id, row.author_name),
252 body: row.body,
253 path: row.path,
254 line: row.line,
255 verdict: row.verdict,
256 created_at: row.created_at,
257 }
258 }
259}
260
261#[derive(Deserialize)]
262pub struct SessionRow {
263 pub seq: u32,
264 pub kind: SessionEntryKind,
265 pub text: String,
266 pub tool: Option<String>,
267 pub commit: Option<String>,
268 pub at: String,
269}
270
271impl From<SessionRow> for SessionEntry {
272 fn from(row: SessionRow) -> Self {
273 SessionEntry {
274 seq: row.seq,
275 kind: row.kind,
276 text: row.text,
277 tool: row.tool,
278 commit: row.commit,
279 at: row.at,
280 }
281 }
282}
283
284/// A pull request whose head a push moved.
285#[derive(Deserialize)]
286pub struct MovedRow {
287 pub id: String,
288 pub repo_id: String,
289 pub number: u32,
290 pub issue_number: Option<u32>,
291 pub status: PullStatus,
292 pub author_id: String,
293 pub author_name: String,
294 #[serde(default)]
295 pub requested_by_id: Option<String>,
296 #[serde(default)]
297 pub requested_by_name: Option<String>,
298}
299
300/// A single number selected as `n`.
301#[derive(Deserialize)]
302pub struct NumberRow {
303 pub n: u32,
304}
305
306/// A single string selected as `value`.
307#[derive(Deserialize)]
308pub struct ValueRow {
309 pub value: String,
310}
311
312/// Rows as the database holds them, for tests of the rules that read them.
313#[cfg(test)]
314pub(crate) mod stored {
315 use super::*;
316
317 /// A pull request g1t made in a fork, read back as stored: g1t as its
318 /// author, and `requested_by` the person who asked, if anyone did.
319 pub(crate) fn pull(author: (&str, &str), requested_by: Option<(&str, &str)>) -> Pull {
320 let row: PullRow = serde_json::from_value(serde_json::json!({
321 "id": "pr_1", "repo_id": "rep_1", "number": 14, "issue_number": 12, "title": "Fix it",
322 "body": null, "agent": "g1t", "runtime": "hosted", "status": "open",
323 "fork_repo_id": "rep_f", "fork_namespace": "pulls", "fork_name": "pr_1",
324 "source_branch": null, "head_commit": null, "merge_base": null, "merged_by": null,
325 "merged_at": null, "superseded_by": null, "check_status": null, "files": null,
326 "assignees": "[]", "reviewers": "[]",
327 "author_id": author.0, "author_name": author.1,
328 "requested_by_id": requested_by.map(|(id, _)| id),
329 "requested_by_name": requested_by.map(|(_, name)| name),
330 "created_at": "", "updated_at": ""
331 }))
332 .unwrap();
333 row.into()
334 }
335
336 /// g1t's agent, as an author is stored.
337 pub(crate) const G1T: (&str, &str) = (g1t_contracts::identity::AGENT_ID, "g1t");
338 /// The person who asked g1t for the work.
339 pub(crate) const ASKER: (&str, &str) = ("usr_1", "syntaqx");
340}
341
342#[cfg(test)]
343mod tests {
344 use super::stored::{ASKER, G1T, pull};
345 use super::*;
346 use g1t_contracts::PrincipalKind;
347
348 #[test]
349 fn g1t_s_pull_request_reads_back_as_g1t_s_requested_by_the_person() {
350 let made = pull(G1T, Some(ASKER));
351 assert_eq!((made.author.username.as_str(), made.author.kind), ("g1t", PrincipalKind::Agent));
352 let asked = made.requested_by.as_ref().expect("who asked is kept");
353 assert_eq!((asked.id.as_str(), asked.username.as_str(), asked.kind), ("usr_1", "syntaqx", PrincipalKind::User));
354 assert_eq!(made.owner().id, "usr_1");
355 }
356
357 #[test]
358 fn anyone_else_s_reads_back_as_theirs_alone() {
359 let own = pull(ASKER, None);
360 assert_eq!(own.author.kind, PrincipalKind::User);
361 assert!(own.requested_by.is_none());
362 assert_eq!(own.owner().id, "usr_1");
363 // Half a requester is nobody.
364 assert!(requester(Some("usr_1".into()), None).is_none());
365 }
366
367 #[test]
368 fn g1t_s_own_work_reads_back_as_g1t_itself() {
369 let own = pull(("g1t", "g1t"), None);
370 assert_eq!(own.author.kind, PrincipalKind::System);
371 assert!(own.requested_by.is_none());
372 }
373}