@volter/twin-github 0.1.2 → 2.0.1

package/client/pulls-rest.ts

@@ -0,0 +1,159 @@
+// The pull-request workspace's reads, through GitHub's own REST API on this origin (docs/contributing/
+// architecture.md, "Screens": a workspace reads and writes only through the pack's operations). The same
+// calls a GitHub client makes: the signed-in person's repositories and their organizations' repositories,
+// each repository's pull requests, and for each pull request its detail, reviews and CI rollup; the one
+// being read also brings its commits, files and both kinds of comments. What comes back is shaped into the
+// props the workspace's components take.
+import type { ChangedFile, Comment, Commit, PullRequest, Review } from './github-mirror.tsx';
+
+type Json = any;
+/** One commit status or check run on the open pull request's head, as its merge box and Checks tab list them. */
+export type Check = { name: string; state: string; description?: string; targetUrl?: string };
+/** A repository as its header counts it: open issues (pull requests excluded) and open pull requests. */
+export type RepoFacts = { openIssues: number; labels: Array<{ name: string; color?: string; description?: string }>; milestones: number; hasDiscussions?: boolean };
+/** A state change on the pull request's timeline (closed, reopened), as GitHub's timeline lists it. */
+export type StateEvent = { event: string; at?: string; actor?: string };
+export type PullsData = {
+  pullRequests: PullRequest[]; reviews: Review[]; commits: Commit[]; comments: Comment[]; reviewComments: Comment[]; files: ChangedFile[];
+  viewer?: string; checks: Check[]; repoFacts: Record<string, RepoFacts>; stateEvents: StateEvent[];
+};
+
+const get = async (base: string, path: string): Promise<Json> => {
+  const r = await fetch(`${base}${path}`, { headers: { accept: 'application/vnd.github+json' } });
+  if (!r.ok) return undefined;
+  return r.json();
+};
+const list = async (base: string, path: string): Promise<Json[]> => {
+  const body = await get(base, path);
+  return Array.isArray(body) ? body : [];
+};
+
+/** A head commit's CI, as GitHub's merge box rolls it up: statuses and check runs together. */
+async function ciOf(base: string, repo: string, sha: string | undefined): Promise<string | undefined> {
+  if (!sha) return undefined;
+  const [combined, checks] = await Promise.all([get(base, `/repos/${repo}/commits/${sha}/status`), get(base, `/repos/${repo}/commits/${sha}/check-runs`)]);
+  const states: string[] = [
+    ...((combined?.statuses ?? []) as Json[]).map((s) => String(s.state)),
+    ...((checks?.check_runs ?? []) as Json[]).map((c) => (c.status === 'completed' ? String(c.conclusion ?? 'neutral') : 'pending')),
+  ];
+  if (!states.length) return undefined;
+  if (states.some((s) => s === 'failure' || s === 'error' || s === 'timed_out' || s === 'cancelled')) return 'failure';
+  if (states.some((s) => s === 'pending')) return 'pending';
+  return 'success';
+}
+
+function pullOf(repo: string, p: Json, ciStatus: string | undefined): PullRequest {
+  const merged = Boolean(p.merged_at);
+  return {
+    repo,
+    number: Number(p.number),
+    title: p.title ?? undefined,
+    body: p.body ?? undefined,
+    state: merged ? 'merged' : String(p.state ?? 'open'),
+    merged,
+    mergedAt: p.merged_at ?? undefined,
+    mergeCommit: p.merge_commit_sha ?? undefined,
+    url: p.html_url ?? undefined,
+    baseBranch: p.base?.ref,
+    headBranch: p.head?.ref,
+    headSha: p.head?.sha,
+    author: p.user?.login,
+    authorAvatarUrl: p.user?.avatar_url,
+    createdAt: p.created_at ?? undefined,
+    updatedAt: p.updated_at ?? undefined,
+    additions: p.additions,
+    deletions: p.deletions,
+    changedFiles: p.changed_files,
+    commitsCount: p.commits,
+    commentsCount: p.comments,
+    reviewCommentsCount: p.review_comments,
+    labels: ((p.labels ?? []) as Json[]).map((l) => ({ name: String(l.name), ...(l.color ? { color: String(l.color) } : {}), ...(l.description ? { description: String(l.description) } : {}) })),
+    assignees: ((p.assignees ?? []) as Json[]).map((a) => String(a.login)),
+    requestedReviewers: ((p.requested_reviewers ?? []) as Json[]).map((r) => String(r.login)),
+    milestone: p.milestone?.title ?? undefined,
+    ciStatus,
+    closedAt: p.closed_at ?? undefined,
+    mergedBy: p.merged_by?.login ?? undefined,
+    mergeable: p.mergeable ?? undefined,
+    draft: Boolean(p.draft),
+  };
+}
+
+const commentOf = (repo: string, number: number) => (c: Json): Comment => ({
+  repo, number, id: c.id, authorAssociation: c.author_association ?? undefined, author: c.user?.login, authorAvatarUrl: c.user?.avatar_url, body: c.body ?? '', createdAt: c.created_at, url: c.html_url, ...(c.path ? { path: String(c.path) } : {}),
+});
+
+/** Every repository the signed-in person can see: their own and their organizations'. */
+async function reposOf(base: string): Promise<string[]> {
+  const own = await list(base, '/user/repos?per_page=100');
+  const orgs = await list(base, '/user/orgs');
+  const theirs = (await Promise.all(orgs.map((o) => list(base, `/orgs/${encodeURIComponent(String(o.login))}/repos?per_page=100`)))).flat();
+  return [...new Set([...own, ...theirs].map((r) => String(r.full_name)))].sort();
+}
+
+/** The checks a head commit carries, statuses and check runs together (the newest status per context). */
+async function checksOf(base: string, repo: string, sha: string | undefined): Promise<Check[]> {
+  if (!sha) return [];
+  const [combined, runs] = await Promise.all([get(base, `/repos/${repo}/commits/${sha}/status`), get(base, `/repos/${repo}/commits/${sha}/check-runs`)]);
+  return [
+    ...((combined?.statuses ?? []) as Json[]).map((s) => ({ name: String(s.context ?? 'default'), state: String(s.state), description: s.description ?? undefined, targetUrl: s.target_url ?? undefined })),
+    ...((runs?.check_runs ?? []) as Json[]).map((c) => ({ name: String(c.name), state: c.status === 'completed' ? String(c.conclusion ?? 'neutral') : 'pending', description: c.output?.title ?? undefined, targetUrl: c.details_url ?? c.html_url ?? undefined })),
+  ];
+}
+
+/** What a repository's header and list filters show: its open issues, its labels (with their colours) and milestones. */
+async function factsOf(base: string, repo: string): Promise<RepoFacts> {
+  const [issues, labels, milestones, meta] = await Promise.all([
+    list(base, `/repos/${repo}/issues?state=open&per_page=100`),
+    list(base, `/repos/${repo}/labels?per_page=100`),
+    list(base, `/repos/${repo}/milestones?per_page=100`),
+    get(base, `/repos/${repo}`),
+  ]);
+  return {
+    openIssues: issues.filter((i) => !i.pull_request).length,
+    labels: labels.map((l) => ({ name: String(l.name), ...(l.color ? { color: String(l.color) } : {}), ...(l.description ? { description: String(l.description) } : {}) })),
+    milestones: milestones.length,
+    hasDiscussions: Boolean(meta?.has_discussions),
+  };
+}
+
+/** The workspace's data: every pull request with its reviews and CI, and the open one's thread in full. */
+export async function loadPulls(base: string, open?: { repo: string; number: number }): Promise<PullsData> {
+  const repos = await reposOf(base);
+  const viewer = (await get(base, '/user'))?.login as string | undefined;
+  const repoFacts: Record<string, RepoFacts> = Object.fromEntries(await Promise.all(repos.map(async (r) => [r, await factsOf(base, r)] as const)));
+  const pullRequests: PullRequest[] = [];
+  const reviews: Review[] = [];
+  for (const repo of repos) {
+    for (const summary of await list(base, `/repos/${repo}/pulls?state=all&per_page=100`)) {
+      const number = Number(summary.number);
+      const [detail, reviewed] = await Promise.all([get(base, `/repos/${repo}/pulls/${number}`), list(base, `/repos/${repo}/pulls/${number}/reviews`)]);
+      const p = detail ?? summary;
+      // GitHub's pull request carries no review count; the list the workspace just read is it
+      pullRequests.push({ ...pullOf(repo, p, await ciOf(base, repo, p.head?.sha)), reviewCount: reviewed.length });
+      for (const r of reviewed) reviews.push({ repo, number, id: r.id, reviewer: r.user?.login, reviewerAvatarUrl: r.user?.avatar_url, state: r.state, body: r.body ?? '', submittedAt: r.submitted_at });
+    }
+  }
+  if (!open) return { pullRequests, reviews, commits: [], comments: [], reviewComments: [], files: [], viewer, checks: [], repoFacts, stateEvents: [] };
+  const { repo, number } = open;
+  const [commits, files, comments, reviewComments, timeline] = await Promise.all([
+    list(base, `/repos/${repo}/pulls/${number}/commits?per_page=100`),
+    list(base, `/repos/${repo}/pulls/${number}/files?per_page=100`),
+    list(base, `/repos/${repo}/issues/${number}/comments?per_page=100`),
+    list(base, `/repos/${repo}/pulls/${number}/comments?per_page=100`),
+    list(base, `/repos/${repo}/issues/${number}/timeline?per_page=100`),
+  ]);
+  const checks = await checksOf(base, repo, pullRequests.find((p) => p.repo === repo && p.number === number)?.headSha);
+  return {
+    pullRequests,
+    reviews,
+    viewer,
+    checks,
+    repoFacts,
+    stateEvents: timeline.filter((e) => e.event === "closed" || e.event === "reopened").map((e) => ({ event: String(e.event), at: e.created_at ?? undefined, actor: e.actor?.login ?? undefined })),
+    commits: commits.map((c) => ({ repo, number, sha: String(c.sha), message: c.commit?.message, author: c.commit?.author?.name, authorLogin: c.author?.login, authorAvatarUrl: c.author?.avatar_url, date: c.commit?.author?.date, url: c.html_url })),
+    files: files.map((f) => ({ repo, number, filename: String(f.filename), status: f.status, additions: f.additions, deletions: f.deletions, changes: f.changes, patch: f.patch })),
+    comments: comments.map(commentOf(repo, number)),
+    reviewComments: reviewComments.map(commentOf(repo, number)),
+  };
+}