import { randomUUID } from "node:crypto"; import { eq } from "drizzle-orm"; import { afterAll, beforeAll, describe, expect, it } from "vitest"; import { agents, chatActions, chatConversations, chatEndpointResources, chatEndpoints, chatGitHubReviews, companies, createDb, heartbeatRuns, runIdentityContexts, toolConnections, type Db } from "@paperclipai/db"; import { startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js"; import { captureReviewWaitQueries, seedGitHubReviewWait, setGitHubReviewAssessment, type CapturedReviewWaitQuery } from "./helpers/github-review-wait.js"; import { readInheritedGitHubReviewWait, readInheritedGitHubReviewWaits } from "../services/chat-channels/github/review-wait.js"; const reviewWaitChanges = ["disabled", "inactive", "review_state", "review_agent", "repository", "repository_id", "thread", "publication", "identity", "endpoint_agent", "company"] as const; async function applyReviewWaitChange(db: Db, f: Awaited>, change: typeof reviewWaitChanges[number]) { if (change === "disabled") await db.update(toolConnections).set({ enabled: false }).where(eq(toolConnections.id, f.connectionId)); if (change === "inactive") await db.update(toolConnections).set({ status: "disabled" }).where(eq(toolConnections.id, f.connectionId)); if (change === "review_state") await db.update(chatGitHubReviews).set({ state: "queued" }).where(eq(chatGitHubReviews.id, f.reviewId)); if (change === "review_agent" || change === "endpoint_agent") { const [other] = await db.insert(agents).values({ companyId: f.companyId, name: "Other", adapterType: "process" }).returning(); if (change === "review_agent") await db.update(heartbeatRuns).set({ agentId: other!.id }).where(eq(heartbeatRuns.id, f.reviewRunId)); else await db.update(chatEndpoints).set({ assignedAgentId: other!.id }).where(eq(chatEndpoints.id, f.endpointId)); } if (change === "repository") await db.update(chatEndpointResources).set({ providerResourceId: "other/repository" }).where(eq(chatEndpointResources.id, f.resourceId)); if (change === "repository_id") await db.update(chatEndpointResources).set({ metadata: { providerRepositoryId: "43" } }).where(eq(chatEndpointResources.id, f.resourceId)); if (change === "thread") await db.update(chatConversations).set({ externalThreadId: "github:synthetic/repository:8" }).where(eq(chatConversations.id, f.conversationId)); if (change === "publication") await db.update(chatActions).set({ status: "received" }).where(eq(chatActions.id, f.publicationId)); if (change === "identity") await db.update(runIdentityContexts).set({ status: "rejected" }).where(eq(runIdentityContexts.id, f.activeIdentityContextId!)); if (change === "company") { const otherCompanyId = randomUUID(); await db.insert(companies).values({ id: otherCompanyId, name: "Other", issuePrefix: otherCompanyId }); f.run = { ...f.run, companyId: otherCompanyId }; } } /** Record the SQL text of every statement that the client sends. */ async function withStatements(db: Db, read: () => Promise) { const client = db.$client as unknown as { unsafe: (query: string, ...rest: unknown[]) => unknown }; const unsafe = client.unsafe; const sql: string[] = []; client.unsafe = (query: string, ...rest: unknown[]) => { sql.push(query); return unsafe.call(client, query, ...rest); }; try { return { result: await read(), sql }; } finally { client.unsafe = unsafe; } } describe("inherited GitHub review wait projection", () => { let temporary: Awaited>; let db: Db; beforeAll(async () => { if (process.env.PAPERCLIP_TEST_DATABASE_URL) { db = createDb(process.env.PAPERCLIP_TEST_DATABASE_URL); } else { temporary = await startEmbeddedPostgresTestDatabase("github-review-wait-"); db = createDb(temporary.connectionString); } }, 30_000); afterAll(async () => { await db?.$client.end({ timeout: 0 }); await temporary?.cleanup(); }); it("reads the typed commit without transferring the assessment document", async () => { const f = await seedGitHubReviewWait(db); const assessment = { reviewedCommit: f.headSha, summary: "Large summary ".repeat(600), findings: [{ body: "retained" }] }; await setGitHubReviewAssessment(db, f.reviewId, assessment); const queries: CapturedReviewWaitQuery[] = []; expect(await readInheritedGitHubReviewWait(captureReviewWaitQueries(db, queries), f.run)).toMatchObject({ kind: "published", reviewId: f.reviewId, headSha: f.headSha, context: { wakeCommentId: f.commentId }, }); const query = queries.find(query => query.sql.includes('join "chat_github_reviews"'))!; const rows = await db.$client.unsafe(query.sql, query.params as never[]).raw(); expect(rows).toHaveLength(1); expect(rows[0]!.reduce((bytes, value) => bytes + (value?.byteLength ?? 0), 0)).toBeLessThan(1_000); const [stored] = await db.select({ assessment: chatGitHubReviews.assessment }).from(chatGitHubReviews) .where(eq(chatGitHubReviews.id, f.reviewId)); expect(stored!.assessment).toEqual(assessment); }); it("preserves strict equality for malformed, missing, and valid JSON values", async () => { const f = await seedGitHubReviewWait(db); for (const assessment of [null, false, 123, f.headSha, [], [f.headSha], {}, { reviewedCommit: null }, { reviewedCommit: 1 }, { reviewedCommit: true }, { reviewedCommit: [f.headSha] }, { reviewedCommit: { value: f.headSha } }, { reviewedCommit: ` ${f.headSha}` }, { reviewedCommit: "2".repeat(40) }, { reviewedCommit: f.headSha }]) { await setGitHubReviewAssessment(db, f.reviewId, assessment); const expected = (assessment as { reviewedCommit?: unknown } | null)?.reviewedCommit === f.headSha; expect((await readInheritedGitHubReviewWait(db, f.run))?.kind).toBe(expected ? "published" : "revoked"); } await db.$client.unsafe("UPDATE chat_github_reviews SET head_sha = '1', assessment = '{\"reviewedCommit\":1}' WHERE id = $1", [f.reviewId]); expect(await readInheritedGitHubReviewWait(db, f.run)).toEqual({ kind: "revoked" }); await db.$client.unsafe("UPDATE chat_github_reviews SET assessment = NULL WHERE id = $1", [f.reviewId]); expect(await readInheritedGitHubReviewWait(db, f.run)).toEqual({ kind: "revoked" }); }); it.each(reviewWaitChanges)( "continues to reject a changed %s binding", async change => { const f = await seedGitHubReviewWait(db); expect((await readInheritedGitHubReviewWait(db, f.run))?.kind).toBe("published"); await applyReviewWaitChange(db, f, change); expect((await readInheritedGitHubReviewWait(db, f.run))?.kind).not.toBe("published"); expect((await readInheritedGitHubReviewWaits(db, [f.run]))[0]?.kind).not.toBe("published"); }, ); it("reads the waits of many runs with one review read and the same results", async () => { const [companyId, agentId] = [randomUUID(), randomUUID()]; await db.insert(companies).values({ id: companyId, name: "Batch", issuePrefix: companyId }); await db.insert(agents).values({ id: agentId, companyId, name: "Reviewer", adapterType: "process" }); const fixtures: Array>> = []; for (const change of [null, ...reviewWaitChanges, "newer_head", "no_identity", "no_issue", null] as const) { const f = await seedGitHubReviewWait(db, change === "company" ? undefined : { companyId, agentId }); if (change === "newer_head") { const [review] = await db.select().from(chatGitHubReviews).where(eq(chatGitHubReviews.id, f.reviewId)); await db.insert(chatGitHubReviews).values({ ...review!, id: randomUUID(), deliveryId: randomUUID(), headSha: "2".repeat(40), state: "queued", createdAt: new Date(review!.createdAt.getTime() + 1_000) }); } else if (change === "no_identity") f.run = { ...f.run, activeIdentityContextId: null }; else if (change === "no_issue") f.run = { ...f.run, nativeIssueId: null }; else if (change) await applyReviewWaitChange(db, f, change); fixtures.push(f); } // A run can be read twice in one pass. const [first] = fixtures; // The "company" wait moved its run to a third company; its own company // also has one published wait. const otherCompany = await seedGitHubReviewWait(db); const runs = [...fixtures.map(f => f.run), first!.run, otherCompany.run]; const single = []; for (const run of runs) single.push(await readInheritedGitHubReviewWait(db, run)); expect(single.filter(wait => wait?.kind === "published")).toHaveLength(4); // No identity, no task, and an endpoint of another agent have no inherited wait. expect(single.filter(wait => wait === null)).toHaveLength(3); expect(single.filter(wait => wait?.kind === "revoked")).toHaveLength(runs.length - 7); const { result, sql } = await withStatements(db, () => readInheritedGitHubReviewWaits(db, runs)); expect(result).toEqual(single); // One review read and one publication read for each company with a source // comment, not one of each for every run. expect(sql.filter(text => /join "chat_github_reviews"/i.test(text))).toHaveLength(2); expect(sql.filter(text => /from "chat_actions"/i.test(text))).toHaveLength(2); expect(await readInheritedGitHubReviewWaits(db, [])).toEqual([]); }); it("reads the waits of forty runs with the statements of four runs", async () => { const first = await seedGitHubReviewWait(db); const runs = [first.run]; while (runs.length < 40) runs.push((await seedGitHubReviewWait(db, { companyId: first.companyId, agentId: first.agentId })).run); const few = await withStatements(db, () => readInheritedGitHubReviewWaits(db, runs.slice(0, 4))); const many = await withStatements(db, () => readInheritedGitHubReviewWaits(db, runs)); expect(many.result.map(wait => wait?.kind)).toEqual(runs.map(() => "published")); expect(many.result.slice(0, 4)).toEqual(few.result); // The requester lineage, the source message link, the reviews and the // publications: one statement each, for any number of runs. expect({ few: few.sql.length, many: many.sql.length }).toEqual({ few: 4, many: 4 }); expect(many.sql.filter(text => /from "run_identity_contexts"/i.test(text))).toHaveLength(1); expect(many.sql.filter(text => /from "chat_message_links"/i.test(text))).toHaveLength(2); }); it("binds each call afresh while reusing the compiled query", async () => { const first = await seedGitHubReviewWait(db), second = await seedGitHubReviewWait(db); const queries: CapturedReviewWaitQuery[] = []; const captured = captureReviewWaitQueries(db, queries); for (const f of [first, second, first]) { expect(await readInheritedGitHubReviewWait(captured, f.run)).toMatchObject({ reviewId: f.reviewId }); } const joined = queries.filter(query => query.sql.includes('join "chat_github_reviews"')); expect(joined).toHaveLength(3); expect(joined[0]).toEqual(joined[2]); expect(joined[0]!.sql).toBe(joined[1]!.sql); expect(joined[0]!.params).not.toEqual(joined[1]!.params); }); it("keeps transaction and savepoint reads on their own sessions", async () => { const f = await seedGitHubReviewWait(db); expect((await readInheritedGitHubReviewWait(db, f.run))?.kind).toBe("published"); await expect(db.transaction(async tx => { const scoped = tx as unknown as Db; await tx.update(toolConnections).set({ enabled: false }).where(eq(toolConnections.id, f.connectionId)); expect(await readInheritedGitHubReviewWait(scoped, f.run)).toEqual({ kind: "revoked" }); await expect(tx.transaction(async savepoint => { await savepoint.update(toolConnections).set({ enabled: true }).where(eq(toolConnections.id, f.connectionId)); expect((await readInheritedGitHubReviewWait(savepoint as unknown as Db, f.run))?.kind).toBe("published"); throw new Error("rollback savepoint"); })).rejects.toThrow("rollback savepoint"); expect(await readInheritedGitHubReviewWait(scoped, f.run)).toEqual({ kind: "revoked" }); throw new Error("rollback transaction"); })).rejects.toThrow("rollback transaction"); expect((await readInheritedGitHubReviewWait(db, f.run))?.kind).toBe("published"); }); it("does not reuse an older completed review when a newer head is queued", async () => { const f = await seedGitHubReviewWait(db); expect((await readInheritedGitHubReviewWait(db, f.run))?.kind).toBe("published"); const [review] = await db.select().from(chatGitHubReviews).where(eq(chatGitHubReviews.id, f.reviewId)); await db.insert(chatGitHubReviews).values({ ...review!, id: randomUUID(), deliveryId: randomUUID(), headSha: "2".repeat(40), state: "queued", createdAt: new Date(review!.createdAt.getTime() + 1_000) }); expect(await readInheritedGitHubReviewWait(db, f.run)).toEqual({ kind: "revoked" }); expect(await readInheritedGitHubReviewWait(db, { ...f.run, nativeIssueId: null })).toBeNull(); expect(await readInheritedGitHubReviewWait(db, { ...f.run, activeIdentityContextId: null })).toBeNull(); }); });