Open History to see the last commit
1import type {
2 PullRequestAction,
3 PullRequestMergeMethod,
4 PullRequestStackHead,
5} from "@t3tools/contracts";
6import * as Effect from "effect/Effect";
7import * as Clock from "effect/Clock";
8import { GraphQLClient, GraphQLClientError, GraphQLResolver } from "effect/graphql";
9import * as RequestResolver from "effect/RequestResolver";
10import * as Result from "effect/Result";
11import * as Schema from "effect/Schema";
12
13import * as GitHubRest from "./GitHubRest.ts";
14import * as GitHubGraphQlClient from "./gitHubGraphQlClient.ts";
15import { decodePullRequestStacksJson, toCanWrite } from "./gitHubPullRequestJson.ts";
16import { cascadeRebaseStack } from "./githubStackRebase.ts";
17import { StackActionsGraphQLGroup } from "./stackActions.graphql.ts";
18
19const stackErrorIdentity = {
20 repository: Schema.String,
21 number: Schema.Int,
22 stackNumber: Schema.Int,
23};
24
25export class GitHubStackChangedError extends Schema.TaggedError<GitHubStackChangedError>()(
26 "GitHubStackChangedError",
27 { ...stackErrorIdentity, completed: Schema.Int },
28) {
29 override get message(): string {
30 return this.completed > 0
31 ? `The stack changed at PR #${this.number} after ${this.completed} layers. Earlier updates remain on GitHub. Refresh it before trying again.`
32 : "The stack changed. Refresh it before trying again.";
33 }
34}
35
36export class GitHubStackUnsupportedError extends Schema.TaggedError<GitHubStackUnsupportedError>()(
37 "GitHubStackUnsupportedError",
38 stackErrorIdentity,
39) {
40 override get message(): string {
41 return "This operation is not supported for this stack.";
42 }
43}
44
45export class GitHubStackResponseInvalidError extends Schema.TaggedError<GitHubStackResponseInvalidError>()(
46 "GitHubStackResponseInvalidError",
47 { ...stackErrorIdentity, cause: Schema.optional(Schema.Defect()) },
48) {
49 override get message(): string {
50 return "GitHub returned an unreadable stack operation response.";
51 }
52}
53
54export class GitHubStackMergeRejectedError extends Schema.TaggedError<GitHubStackMergeRejectedError>()(
55 "GitHubStackMergeRejectedError",
56 { ...stackErrorIdentity, cause: Schema.Defect() },
57) {
58 override get message(): string {
59 return "GitHub refused the stack merge. Check the stack's branch rules and merge requirements.";
60 }
61}
62
63export class GitHubStackMergePendingError extends Schema.TaggedError<GitHubStackMergePendingError>()(
64 "GitHubStackMergePendingError",
65 stackErrorIdentity,
66) {
67 override get message(): string {
68 return "The merge is still running on GitHub. Check its status there before submitting another request.";
69 }
70}
71
72export class GitHubStackPermissionError extends Schema.TaggedError<GitHubStackPermissionError>()(
73 "GitHubStackPermissionError",
74 stackErrorIdentity,
75) {
76 override get message(): string {
77 return "You cannot update every branch in this stack. Check write access and fork maintainer permissions before retrying.";
78 }
79}
80
81export class GitHubStackRebaseFailedError extends Schema.TaggedError<GitHubStackRebaseFailedError>()(
82 "GitHubStackRebaseFailedError",
83 { ...stackErrorIdentity, completed: Schema.Int, cause: Schema.Defect() },
84) {
85 override get message(): string {
86 return this.cause instanceof Error && this.cause.message !== ""
87 ? this.cause.message
88 : `Stack rebase stopped at PR #${this.number} after ${this.completed} layers. Earlier updates remain on GitHub; resolve the failing layer before retrying.`;
89 }
90}
91
92export type GitHubStackActionError =
93 | GitHubStackChangedError
94 | GitHubStackUnsupportedError
95 | GitHubStackResponseInvalidError
96 | GitHubStackMergeRejectedError
97 | GitHubStackMergePendingError
98 | GitHubStackPermissionError
99 | GitHubStackRebaseFailedError;
100
101const MergeResponse = Schema.Struct({
102 status: Schema.Literals(["pending", "merged", "enqueued", "failed"]),
103 details: Schema.Struct({
104 uuid: Schema.optional(Schema.String),
105 message: Schema.optional(Schema.String),
106 }),
107});
108
109const decodeMergeResponse = Schema.decodeEffect(Schema.fromJsonString(MergeResponse));
110
111export const runGitHubStackAction = Effect.fn("runGitHubStackAction")(function* (input: {
112 cwd: string;
113 repository: string;
114 host: string;
115 number: number;
116 stackNumber: number;
117 expectedStackHeads?: ReadonlyArray<PullRequestStackHead>;
118 action: PullRequestAction;
119 mergeMethod?: PullRequestMergeMethod;
120}) {
121 const api = yield* GitHubRest.GitHubRest;
122 const identity = {
123 repository: input.repository,
124 number: input.number,
125 stackNumber: input.stackNumber,
126 };
127 if (input.action !== "merge" && input.action !== "update-branch")
128 return yield* new GitHubStackUnsupportedError({ ...identity });
129 const endpoint = `repos/${input.repository}`;
130 const read = yield* api.rest({
131 host: input.host,
132 operation: "runGitHubStackAction",
133 path: `${endpoint}/stacks?pull_request=${input.number}`,
134 });
135 const decoded = decodePullRequestStacksJson(read.body);
136 if (Result.isFailure(decoded))
137 return yield* new GitHubStackResponseInvalidError({ ...identity, cause: decoded.failure });
138 const stack = decoded.success;
139 const targetIndex = stack?.layers.findIndex((layer) => layer.number === input.number) ?? -1;
140 const target = stack?.layers[targetIndex];
141 if (
142 stack?.number !== input.stackNumber ||
143 target === undefined ||
144 (input.action === "update-branch" && targetIndex !== stack.layers.length - 1)
145 ) {
146 return yield* new GitHubStackChangedError({ ...identity, number: input.number, completed: 0 });
147 }
148 const affectedLayers =
149 input.action === "merge" ? stack.layers.slice(0, targetIndex + 1) : stack.layers;
150 const open = affectedLayers.filter((layer) => layer.state !== "merged");
151 if (input.action === "merge" && target.state !== "open")
152 return yield* new GitHubStackUnsupportedError({ ...identity });
153 if (
154 !input.expectedStackHeads ||
155 input.expectedStackHeads.length !== open.length ||
156 new Set(input.expectedStackHeads.map((layer) => layer.number)).size !== open.length ||
157 open.some(
158 (layer) =>
159 !layer.headSha ||
160 !input.expectedStackHeads?.some(
161 (expected) => expected.number === layer.number && expected.headSha === layer.headSha,
162 ),
163 )
164 ) {
165 return yield* new GitHubStackChangedError({ ...identity, number: input.number, completed: 0 });
166 }
167 if (open.length === 0 || open.some((layer) => layer.state !== "open"))
168 return yield* new GitHubStackUnsupportedError({ ...identity });
169 if (input.action === "update-branch") {
170 const [owner, name] = input.repository.split("/");
171 const client = yield* GraphQLClient.make(
172 StackActionsGraphQLGroup.middleware(GitHubGraphQlClient.GitHubGraphQlAuth),
173 ).pipe(Effect.provide(GitHubGraphQlClient.layer));
174 const resolver = GraphQLResolver.aliased(client.PullRequestBranchAccess, {
175 batchKey: GitHubGraphQlClient.batchKey,
176 }).pipe(RequestResolver.batchN(open.length));
177 const access = yield* Effect.forEach(
178 open,
179 (layer) =>
180 GraphQLResolver.request({ owner: owner!, name: name!, number: layer.number }, resolver),
181 { concurrency: "unbounded" },
182 ).pipe(
183 GitHubGraphQlClient.call({
184 host: input.host,
185 operation: "runGitHubStackAction",
186 allowReserve: true,
187 }),
188 Effect.catchIf(
189 GraphQLClientError.isGraphQLClientError,
190 (cause) => new GitHubStackResponseInvalidError({ ...identity, cause }),
191 ),
192 );
193 // Current layers report viewerCanUpdateBranch=false even if restacking could make them stale.
194 if (
195 access.some(({ repository }) => {
196 const pr = repository?.pullRequest;
197 return (
198 !pr?.headRepository ||
199 (!pr.maintainerCanModify && !toCanWrite(pr.headRepository.viewerPermission))
200 );
201 })
202 )
203 return yield* new GitHubStackPermissionError({ ...identity });
204 const mergedHeadSha = stack.layers[stack.layers.indexOf(open[0]!) - 1]?.headSha;
205 // GitHub has no stack-rebase API; per-PR updates replay lower layers' old commits.
206 yield* cascadeRebaseStack({
207 host: input.host,
208 repository: input.repository,
209 base: stack.base,
210 layers: open.map((layer) => ({
211 number: layer.number,
212 headBranch: layer.headBranch,
213 headSha: layer.headSha!,
214 })),
215 ...(mergedHeadSha === undefined ? {} : { mergedHeadSha }),
216 }).pipe(
217 Effect.mapError((cause) =>
218 cause._tag === "GitHubStackRebaseConflictError" ||
219 cause._tag === "GitHubStackRebaseGitError"
220 ? new GitHubStackRebaseFailedError({
221 ...identity,
222 number: cause.number,
223 completed: cause.completed,
224 cause,
225 })
226 : cause,
227 ),
228 );
229 return;
230 }
231 if (open.some((layer) => layer.isDraft))
232 return yield* new GitHubStackUnsupportedError({ ...identity });
233 const decode = (raw: string) =>
234 decodeMergeResponse(raw).pipe(
235 Effect.mapError((cause) => new GitHubStackResponseInvalidError({ ...identity, cause })),
236 );
237 const request = yield* api.rest({
238 host: input.host,
239 operation: "runGitHubStackAction",
240 method: "PUT",
241 path: `${endpoint}/pulls/${input.number}/merge-async`,
242 body: {
243 merge_method: input.mergeMethod ?? "merge",
244 merge_action: "default",
245 sha: target.headSha,
246 },
247 });
248 let result = yield* decode(request.body);
249 const deadline = (yield* Clock.currentTimeMillis) + 5 * 60_000;
250 for (
251 let attempt = 0;
252 result.status === "pending" && (yield* Clock.currentTimeMillis) < deadline;
253 attempt++
254 ) {
255 const uuid = result.details.uuid;
256 if (!uuid) return yield* new GitHubStackResponseInvalidError({ ...identity });
257 yield* Effect.sleep(Math.min(1_000 * 2 ** attempt, 10_000));
258 const poll = yield* api.rest({
259 host: input.host,
260 operation: "runGitHubStackAction",
261 path: `${endpoint}/pulls/${input.number}/merge-async/${encodeURIComponent(uuid)}`,
262 });
263 result = yield* decode(poll.body);
264 }
265 if (result.status === "pending") return yield* new GitHubStackMergePendingError({ ...identity });
266 if (result.status === "failed")
267 return yield* new GitHubStackMergeRejectedError({ ...identity, cause: result });
268});