sailfork / t3code-github / packages/ source-control-github/ src/ server/ githubStackActions.ts

import type {
  PullRequestAction,
  PullRequestMergeMethod,
  PullRequestStackHead,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Clock from "effect/Clock";
import { GraphQLClient, GraphQLClientError, GraphQLResolver } from "effect/graphql";
import * as RequestResolver from "effect/RequestResolver";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";

import * as GitHubRest from "./GitHubRest.ts";
import * as GitHubGraphQlClient from "./gitHubGraphQlClient.ts";
import { decodePullRequestStacksJson, toCanWrite } from "./gitHubPullRequestJson.ts";
import { cascadeRebaseStack } from "./githubStackRebase.ts";
import { StackActionsGraphQLGroup } from "./stackActions.graphql.ts";

const stackErrorIdentity = {
  repository: Schema.String,
  number: Schema.Int,
  stackNumber: Schema.Int,
};

export class GitHubStackChangedError extends Schema.TaggedError<GitHubStackChangedError>()(
  "GitHubStackChangedError",
  { ...stackErrorIdentity, completed: Schema.Int },
) {
  override get message(): string {
    return this.completed > 0
      ? `The stack changed at PR #${this.number} after ${this.completed} layers. Earlier updates remain on GitHub. Refresh it before trying again.`
      : "The stack changed. Refresh it before trying again.";
  }
}

export class GitHubStackUnsupportedError extends Schema.TaggedError<GitHubStackUnsupportedError>()(
  "GitHubStackUnsupportedError",
  stackErrorIdentity,
) {
  override get message(): string {
    return "This operation is not supported for this stack.";
  }
}

export class GitHubStackResponseInvalidError extends Schema.TaggedError<GitHubStackResponseInvalidError>()(
  "GitHubStackResponseInvalidError",
  { ...stackErrorIdentity, cause: Schema.optional(Schema.Defect()) },
) {
  override get message(): string {
    return "GitHub returned an unreadable stack operation response.";
  }
}

export class GitHubStackMergeRejectedError extends Schema.TaggedError<GitHubStackMergeRejectedError>()(
  "GitHubStackMergeRejectedError",
  { ...stackErrorIdentity, cause: Schema.Defect() },
) {
  override get message(): string {
    return "GitHub refused the stack merge. Check the stack's branch rules and merge requirements.";
  }
}

export class GitHubStackMergePendingError extends Schema.TaggedError<GitHubStackMergePendingError>()(
  "GitHubStackMergePendingError",
  stackErrorIdentity,
) {
  override get message(): string {
    return "The merge is still running on GitHub. Check its status there before submitting another request.";
  }
}

export class GitHubStackPermissionError extends Schema.TaggedError<GitHubStackPermissionError>()(
  "GitHubStackPermissionError",
  stackErrorIdentity,
) {
  override get message(): string {
    return "You cannot update every branch in this stack. Check write access and fork maintainer permissions before retrying.";
  }
}

export class GitHubStackRebaseFailedError extends Schema.TaggedError<GitHubStackRebaseFailedError>()(
  "GitHubStackRebaseFailedError",
  { ...stackErrorIdentity, completed: Schema.Int, cause: Schema.Defect() },
) {
  override get message(): string {
    return this.cause instanceof Error && this.cause.message !== ""
      ? this.cause.message
      : `Stack rebase stopped at PR #${this.number} after ${this.completed} layers. Earlier updates remain on GitHub; resolve the failing layer before retrying.`;
  }
}

export type GitHubStackActionError =
  | GitHubStackChangedError
  | GitHubStackUnsupportedError
  | GitHubStackResponseInvalidError
  | GitHubStackMergeRejectedError
  | GitHubStackMergePendingError
  | GitHubStackPermissionError
  | GitHubStackRebaseFailedError;

const MergeResponse = Schema.Struct({
  status: Schema.Literals(["pending", "merged", "enqueued", "failed"]),
  details: Schema.Struct({
    uuid: Schema.optional(Schema.String),
    message: Schema.optional(Schema.String),
  }),
});

const decodeMergeResponse = Schema.decodeEffect(Schema.fromJsonString(MergeResponse));

export const runGitHubStackAction = Effect.fn("runGitHubStackAction")(function* (input: {
  cwd: string;
  repository: string;
  host: string;
  number: number;
  stackNumber: number;
  expectedStackHeads?: ReadonlyArray<PullRequestStackHead>;
  action: PullRequestAction;
  mergeMethod?: PullRequestMergeMethod;
}) {
  const api = yield* GitHubRest.GitHubRest;
  const identity = {
    repository: input.repository,
    number: input.number,
    stackNumber: input.stackNumber,
  };
  if (input.action !== "merge" && input.action !== "update-branch")
    return yield* new GitHubStackUnsupportedError({ ...identity });
  const endpoint = `repos/${input.repository}`;
  const read = yield* api.rest({
    host: input.host,
    operation: "runGitHubStackAction",
    path: `${endpoint}/stacks?pull_request=${input.number}`,
  });
  const decoded = decodePullRequestStacksJson(read.body);
  if (Result.isFailure(decoded))
    return yield* new GitHubStackResponseInvalidError({ ...identity, cause: decoded.failure });
  const stack = decoded.success;
  const targetIndex = stack?.layers.findIndex((layer) => layer.number === input.number) ?? -1;
  const target = stack?.layers[targetIndex];
  if (
    stack?.number !== input.stackNumber ||
    target === undefined ||
    (input.action === "update-branch" && targetIndex !== stack.layers.length - 1)
  ) {
    return yield* new GitHubStackChangedError({ ...identity, number: input.number, completed: 0 });
  }
  const affectedLayers =
    input.action === "merge" ? stack.layers.slice(0, targetIndex + 1) : stack.layers;
  const open = affectedLayers.filter((layer) => layer.state !== "merged");
  if (input.action === "merge" && target.state !== "open")
    return yield* new GitHubStackUnsupportedError({ ...identity });
  if (
    !input.expectedStackHeads ||
    input.expectedStackHeads.length !== open.length ||
    new Set(input.expectedStackHeads.map((layer) => layer.number)).size !== open.length ||
    open.some(
      (layer) =>
        !layer.headSha ||
        !input.expectedStackHeads?.some(
          (expected) => expected.number === layer.number && expected.headSha === layer.headSha,
        ),
    )
  ) {
    return yield* new GitHubStackChangedError({ ...identity, number: input.number, completed: 0 });
  }
  if (open.length === 0 || open.some((layer) => layer.state !== "open"))
    return yield* new GitHubStackUnsupportedError({ ...identity });
  if (input.action === "update-branch") {
    const [owner, name] = input.repository.split("/");
    const client = yield* GraphQLClient.make(
      StackActionsGraphQLGroup.middleware(GitHubGraphQlClient.GitHubGraphQlAuth),
    ).pipe(Effect.provide(GitHubGraphQlClient.layer));
    const resolver = GraphQLResolver.aliased(client.PullRequestBranchAccess, {
      batchKey: GitHubGraphQlClient.batchKey,
    }).pipe(RequestResolver.batchN(open.length));
    const access = yield* Effect.forEach(
      open,
      (layer) =>
        GraphQLResolver.request({ owner: owner!, name: name!, number: layer.number }, resolver),
      { concurrency: "unbounded" },
    ).pipe(
      GitHubGraphQlClient.call({
        host: input.host,
        operation: "runGitHubStackAction",
        allowReserve: true,
      }),
      Effect.catchIf(
        GraphQLClientError.isGraphQLClientError,
        (cause) => new GitHubStackResponseInvalidError({ ...identity, cause }),
      ),
    );
    // Current layers report viewerCanUpdateBranch=false even if restacking could make them stale.
    if (
      access.some(({ repository }) => {
        const pr = repository?.pullRequest;
        return (
          !pr?.headRepository ||
          (!pr.maintainerCanModify && !toCanWrite(pr.headRepository.viewerPermission))
        );
      })
    )
      return yield* new GitHubStackPermissionError({ ...identity });
    const mergedHeadSha = stack.layers[stack.layers.indexOf(open[0]!) - 1]?.headSha;
    // GitHub has no stack-rebase API; per-PR updates replay lower layers' old commits.
    yield* cascadeRebaseStack({
      host: input.host,
      repository: input.repository,
      base: stack.base,
      layers: open.map((layer) => ({
        number: layer.number,
        headBranch: layer.headBranch,
        headSha: layer.headSha!,
      })),
      ...(mergedHeadSha === undefined ? {} : { mergedHeadSha }),
    }).pipe(
      Effect.mapError((cause) =>
        cause._tag === "GitHubStackRebaseConflictError" ||
        cause._tag === "GitHubStackRebaseGitError"
          ? new GitHubStackRebaseFailedError({
              ...identity,
              number: cause.number,
              completed: cause.completed,
              cause,
            })
          : cause,
      ),
    );
    return;
  }
  if (open.some((layer) => layer.isDraft))
    return yield* new GitHubStackUnsupportedError({ ...identity });
  const decode = (raw: string) =>
    decodeMergeResponse(raw).pipe(
      Effect.mapError((cause) => new GitHubStackResponseInvalidError({ ...identity, cause })),
    );
  const request = yield* api.rest({
    host: input.host,
    operation: "runGitHubStackAction",
    method: "PUT",
    path: `${endpoint}/pulls/${input.number}/merge-async`,
    body: {
      merge_method: input.mergeMethod ?? "merge",
      merge_action: "default",
      sha: target.headSha,
    },
  });
  let result = yield* decode(request.body);
  const deadline = (yield* Clock.currentTimeMillis) + 5 * 60_000;
  for (
    let attempt = 0;
    result.status === "pending" && (yield* Clock.currentTimeMillis) < deadline;
    attempt++
  ) {
    const uuid = result.details.uuid;
    if (!uuid) return yield* new GitHubStackResponseInvalidError({ ...identity });
    yield* Effect.sleep(Math.min(1_000 * 2 ** attempt, 10_000));
    const poll = yield* api.rest({
      host: input.host,
      operation: "runGitHubStackAction",
      path: `${endpoint}/pulls/${input.number}/merge-async/${encodeURIComponent(uuid)}`,
    });
    result = yield* decode(poll.body);
  }
  if (result.status === "pending") return yield* new GitHubStackMergePendingError({ ...identity });
  if (result.status === "failed")
    return yield* new GitHubStackMergeRejectedError({ ...identity, cause: result });
});