0/**
1 * Admin tool — backfill `is_benchmark = true` on existing reviews whose
2 * repo has BENCHMARK.md at root. Mission 6 companion to the webhook-side
3 * detection change: new reviews on benchmark-class repos get isBenchmark=true
4 * automatically, but rows that predate the flip are still locked at false.
5 * This script catches them up.
6 *
7 * Usage (from apps/web):
8 * pnpm exec tsx scripts/backfill-benchmark-flag.ts # apply
9 * pnpm exec tsx scripts/backfill-benchmark-flag.ts --dry-run # decide only
10 *
11 * Idempotent. Fail closed: a probe error leaves that group untouched.
12 * The exported runBenchmarkBackfill() function is the testable core —
13 * main() just wires real deps (DB + Octokit + isBenchmarkRepo).
14 *
15 * Auth: uses GITHUB_TOKEN if present, else unauthenticated (60 req/h).
16 */
17import { config as loadDotenv } from "dotenv";
18loadDotenv({ path: ".env.local", quiet: true });
19
20// ─── Pure core (testable, no I/O) ──────────────────────────────────────────
21
22export type CandidateGroup = {
23 owner: string;
24 repo: string;
25 reviewIds: string[];
26};
27
28export type BenchmarkCheck =
29 | { kind: "benchmark" }
30 | { kind: "not_benchmark" }
31 | { kind: "error"; error: string };
32
33export type GroupDecision = {
34 owner: string;
35 repo: string;
36 rowCount: number;
37 decision: "benchmark" | "not_benchmark" | "error";
38 error?: string;
39 flipped: number;
40};
41
42export type BackfillSummary = {
43 preState: { totalCandidateRows: number; totalGroups: number };
44 decisions: GroupDecision[];
45 benchmarkGroups: number;
46 nonBenchmarkGroups: number;
47 errorGroups: number;
48 rowsFlipped: number;
49 dryRun: boolean;
50};
51
52export type BackfillDeps = {
53 loadCandidateGroups: () => Promise<CandidateGroup[]>;
54 checkBenchmark: (owner: string, repo: string) => Promise<BenchmarkCheck>;
55 flipRows: (reviewIds: string[]) => Promise<number>;
56 log: (line: string) => void;
57};
58
59export async function runBenchmarkBackfill(
60 deps: BackfillDeps,
61 opts: { dryRun: boolean },
62): Promise<BackfillSummary> {
63 const groups = await deps.loadCandidateGroups();
64 const totalCandidateRows = groups.reduce((sum, g) => sum + g.reviewIds.length, 0);
65
66 deps.log(
67 `[pre-state] ${groups.length} repo group(s) to evaluate; ` +
68 `${totalCandidateRows} candidate row(s) total.`,
69 );
70 if (opts.dryRun) deps.log("[mode] dry-run — no writes will be issued.");
71
72 const decisions: GroupDecision[] = [];
73 let benchmarkGroups = 0;
74 let nonBenchmarkGroups = 0;
75 let errorGroups = 0;
76 let rowsFlipped = 0;
77
78 for (const group of groups) {
79 const check = await deps.checkBenchmark(group.owner, group.repo);
80 if (check.kind === "benchmark") {
81 benchmarkGroups += 1;
82 let flipped = group.reviewIds.length;
83 if (!opts.dryRun) {
84 flipped = await deps.flipRows(group.reviewIds);
85 rowsFlipped += flipped;
86 }
87 decisions.push({
88 owner: group.owner,
89 repo: group.repo,
90 rowCount: group.reviewIds.length,
91 decision: "benchmark",
92 flipped,
93 });
94 deps.log(
95 ` benchmark ${group.owner}/${group.repo} — ` +
96 `${group.reviewIds.length} row(s) ${opts.dryRun ? "would flip" : "flipped"}.`,
97 );
98 } else if (check.kind === "not_benchmark") {
99 nonBenchmarkGroups += 1;
100 decisions.push({
101 owner: group.owner,
102 repo: group.repo,
103 rowCount: group.reviewIds.length,
104 decision: "not_benchmark",
105 flipped: 0,
106 });
107 deps.log(
108 ` not-benchmark ${group.owner}/${group.repo} — ` +
109 `${group.reviewIds.length} row(s) untouched.`,
110 );
111 } else {
112 errorGroups += 1;
113 decisions.push({
114 owner: group.owner,
115 repo: group.repo,
116 rowCount: group.reviewIds.length,
117 decision: "error",
118 error: check.error,
119 flipped: 0,
120 });
121 deps.log(
122 ` error ${group.owner}/${group.repo} — ` +
123 `${group.reviewIds.length} row(s) untouched (${check.error}).`,
124 );
125 }
126 }
127
128 deps.log("");
129 deps.log(
130 `[post-state] benchmark=${benchmarkGroups} not_benchmark=${nonBenchmarkGroups} ` +
131 `error=${errorGroups} rowsFlipped=${rowsFlipped}` +
132 (opts.dryRun ? " (dry-run, no writes)" : ""),
133 );
134
135 return {
136 preState: { totalCandidateRows, totalGroups: groups.length },
137 decisions,
138 benchmarkGroups,
139 nonBenchmarkGroups,
140 errorGroups,
141 rowsFlipped,
142 dryRun: opts.dryRun,
143 };
144}
145
146// ─── Real deps wiring (script entrypoint) ──────────────────────────────────
147
148async function main() {
149 const dryRun = process.argv.slice(2).includes("--dry-run");
150
151 const { Octokit } = await import("@octokit/rest");
152 const { and, eq, isNotNull } = await import("drizzle-orm");
153 const { db } = await import("../db/index");
154 const { reviews } = await import("../db/schema");
155 const { isBenchmarkRepo } = await import("../lib/repo-benchmark");
156
157 const token = process.env["GITHUB_TOKEN"];
158 const octokit = new Octokit(token === undefined || token.length === 0 ? {} : { auth: token });
159
160 const deps: BackfillDeps = {
161 loadCandidateGroups: async () => {
162 // Group eligible rows by (owner, repo). Skip rows missing owner/repo
163 // (predates Mission 3 slice 3-5) — we cannot probe their visibility.
164 const rows = await db
165 .select({
166 reviewId: reviews.reviewId,
167 owner: reviews.owner,
168 repo: reviews.repo,
169 })
170 .from(reviews)
171 .where(
172 and(
173 eq(reviews.isBenchmark, false),
174 isNotNull(reviews.owner),
175 isNotNull(reviews.repo),
176 ),
177 );
178 const byKey = new Map<string, CandidateGroup>();
179 for (const r of rows) {
180 if (r.owner === null || r.repo === null) continue;
181 const key = `${r.owner}/${r.repo}`;
182 const existing = byKey.get(key);
183 if (existing) {
184 existing.reviewIds.push(r.reviewId);
185 } else {
186 byKey.set(key, { owner: r.owner, repo: r.repo, reviewIds: [r.reviewId] });
187 }
188 }
189 return Array.from(byKey.values()).toSorted((a, b) =>
190 `${a.owner}/${a.repo}`.localeCompare(`${b.owner}/${b.repo}`),
191 );
192 },
193 checkBenchmark: async (owner, repo) => {
194 try {
195 const isBench = await isBenchmarkRepo(octokit, owner, repo);
196 return { kind: isBench ? "benchmark" : "not_benchmark" };
197 } catch (err) {
198 const message = err instanceof Error ? err.message : String(err);
199 return { kind: "error", error: message };
200 }
201 },
202 flipRows: async (reviewIds) => {
203 if (reviewIds.length === 0) return 0;
204 const { inArray } = await import("drizzle-orm");
205 const updated = await db
206 .update(reviews)
207 .set({ isBenchmark: true })
208 .where(inArray(reviews.reviewId, reviewIds))
209 .returning({ reviewId: reviews.reviewId });
210 return updated.length;
211 },
212 log: (line) => console.log(line),
213 };
214
215 await runBenchmarkBackfill(deps, { dryRun });
216}
217
218// Only run main() when executed directly, not when imported by tests.
219if (process.argv[1]?.endsWith("backfill-benchmark-flag.ts")) {
220 main().then(
221 () => process.exit(0),
222 (err) => {
223 console.error(err);
224 process.exit(1);
225 },
226 );
227}
228