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

import { resolvePullRequestAuthorFilter, SourceControlProviderKind } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as Result from "effect/Result";
import type { PullRequestCapabilities, PullRequestViewerPermissions } from "@t3tools/contracts";
import { decodeJsonResult } from "@t3tools/shared/schemaJson";
import * as ForgejoCli from "./ForgejoCli.ts";
import { parseDiffFileRevisions } from "@t3tools/source-control-core/server/diffFileRevisions";
import {
  PullRequestProviderError,
  type ProviderChangeRequestDetail,
  type ProviderChangeRequestSummary,
  type ProviderRepositoryRef,
  type PullRequestProviderApi,
} from "@t3tools/source-control-core/server/PullRequestProvider";
import {
  ForgejoPullRequest,
  ForgejoRepository,
  ForgejoUser,
  ForgejoComment,
  ForgejoReview,
  ForgejoReviewComment,
  ForgejoCommit,
  ForgejoStatus,
  ForgejoLabel,
  ForgejoReaction,
  FORGEJO_REACTIONS,
  forgejoChangeRequest,
  forgejoActor,
  forgejoComment,
  forgejoReview,
  forgejoReviewThread,
  forgejoCommit,
  forgejoChecks,
  forgejoReactions,
} from "./forgejoPullRequestJson.ts";
import { ForgejoBranchStatusChecks, markRequiredForgejoChecks } from "./forgejoRequiredChecks.ts";
import { definition } from "../shared/definition.ts";

const isForgejoCliError = Schema.is(ForgejoCli.ForgejoCliError);

const CAPABILITIES: PullRequestCapabilities = {
  diff: true,
  viewedFiles: "environment",
  comment: true,
  actions: [...definition.changeRequestActions],
  mergeMethods: ["merge", "squash", "rebase"],
  updateMethods: ["merge", "rebase"],
  search: false,
  reactions: true,
  mentions: true,
  referenceSigils: [],
  labels: true,
  // Forgejo's public API has no thread replies/resolution or draft conversion endpoint.
  review: {
    inlineComment: true,
    reply: false,
    resolve: false,
    verdicts: ["comment", "approve", "request-changes"],
  },
  reviewers: { request: true, listCandidates: true, searchCandidates: false },
  edit: { changeRequest: true, comment: true },
};
const USER_SEARCH_LIMIT = 50;
const ForgejoUserSearch = Schema.Struct({
  data: Schema.optional(Schema.NullOr(Schema.Array(ForgejoUser))),
});

const UNAVAILABLE_REQUIREMENT = {
  missing:
    "Install Forgejo CLI (`fj` 0.6 or later) from https://codeberg.org/forgejo-contrib/forgejo-cli or Gitea CLI (`tea` 0.16 or later) from https://gitea.com/gitea/tea to browse Forgejo pull requests.",
  unauthenticated:
    "Authenticate your Forgejo or Gitea server with `fj --host <server-url> auth add-token` on the T3 Code server. If fj is missing or unconfigured for that server, use `tea login add`. A configured fj account must be repaired with fj.",
};

const repoPath = (input: ProviderRepositoryRef) =>
  `repos/${input.repository.split("/").map(encodeURIComponent).join("/")}`;
const pullPath = (input: ProviderRepositoryRef & { readonly number: number }) =>
  `${repoPath(input)}/pulls/${input.number}`;
const issuePath = (input: ProviderRepositoryRef & { readonly number: number }) =>
  `${repoPath(input)}/issues/${input.number}`;
// Review IDs differ from the issue-comment IDs used by Forgejo's reactions API.
const reviewCommentId = (review: typeof ForgejoReview.Type) =>
  /#issuecomment-([1-9]\d*)$/.exec(review.html_url ?? "")?.[1];

const decodePullRequest = decodeJsonResult(ForgejoPullRequest);

/** Only the PATCH reply carries the pull request; merge and update reply with an empty body. */
function forgejoActionSummary(stdout: string): ProviderChangeRequestSummary | undefined {
  const decoded = decodePullRequest(stdout);
  if (Result.isFailure(decoded)) return undefined;
  const pr = decoded.success;
  // A state PATCH does not recompute conflicts, so "unknown" there would hide a known conflict.
  const { mergeability, ...summary } = forgejoChangeRequest(pr);
  return {
    ...summary,
    ...(mergeability === "unknown" ? {} : { mergeability }),
    additions: pr.additions ?? undefined,
    deletions: pr.deletions ?? undefined,
    ...(pr.head.sha.trim() === "" ? {} : { headSha: pr.head.sha }),
  };
}

export const make = Effect.gen(function* () {
  const cli = yield* ForgejoCli.ForgejoCli;
  const failure = (operation: string, detail: string, cause?: unknown) =>
    new PullRequestProviderError({
      provider: SourceControlProviderKind.make("forgejo"),
      operation,
      reason: "failed",
      detail,
      ...(cause === undefined ? {} : { cause }),
    });
  const request = (input: ForgejoCli.ForgejoApiInput) =>
    cli.api(input).pipe(
      Effect.mapError(
        (error) =>
          new PullRequestProviderError({
            provider: SourceControlProviderKind.make("forgejo"),
            operation: input.path,
            detail: error.detail,
            cause: error,
            reason:
              error.reason === "missing-cli"
                ? "missing-tool"
                : error.reason === "authentication"
                  ? "unauthenticated"
                  : error.reason === "rate-limit"
                    ? "rate-limited"
                    : error.reason === "not-found"
                      ? "not-found"
                      : "failed",
          }),
      ),
    );
  /** A response, and whether its `link` header points at a further page. */
  const readLinked = Effect.fn("ForgejoPullRequestProvider.readLinked")(function* <A>(
    input: ForgejoCli.ForgejoApiInput,
    schema: Schema.Codec<A, unknown, never, never>,
  ) {
    const result = yield* request(input);
    if (result.stdoutTruncated)
      return yield* failure(input.path, "Forgejo response exceeded the output limit.");
    const decoded = decodeJsonResult(schema)(result.stdout);
    if (Result.isFailure(decoded))
      return yield* failure(input.path, "Forgejo returned an invalid response.", decoded.failure);
    const links = /^link:\s*(.*)$/im.exec(result.stderr)?.[1];
    return { value: decoded.success, next: links !== undefined && /rel="?next"?/i.test(links) };
  });
  const read = <A>(
    input: ForgejoCli.ForgejoApiInput,
    schema: Schema.Codec<A, unknown, never, never>,
  ) => readLinked(input, schema).pipe(Effect.map(({ value }) => value));
  const readArray = <A>(
    input: ForgejoCli.ForgejoApiInput,
    schema: Schema.Codec<A, unknown, never, never>,
  ) => read(input, Schema.NullOr(Schema.Array(schema))).pipe(Effect.map((rows) => rows ?? []));
  const readPage = Effect.fn("ForgejoPullRequestProvider.readPage")(function* <A>(
    input: ForgejoCli.ForgejoApiInput,
    schema: Schema.Codec<A, unknown, never, never>,
    index: number,
  ) {
    const result = yield* request({
      ...input,
      path: `${input.path}${input.path.includes("?") ? "&" : "?"}limit=50&page=${index}`,
    });
    if (result.stdoutTruncated)
      return yield* failure(input.path, "Forgejo response exceeded the output limit.");
    const decoded = decodeJsonResult(Schema.NullOr(Schema.Array(schema)))(result.stdout);
    if (Result.isFailure(decoded))
      return yield* failure(input.path, "Forgejo returned an invalid response.", decoded.failure);
    const rows = decoded.success ?? [];
    const links = /^link:\s*(.*)$/im.exec(result.stderr)?.[1];
    return {
      rows,
      more: rows.length > 0 && (links === undefined || /rel="?next"?/i.test(links)),
    };
  });
  // Forgejo's default page limit is 50.
  const page = Effect.fn("ForgejoPullRequestProvider.page")(function* <A>(
    input: ForgejoCli.ForgejoApiInput,
    schema: Schema.Codec<A, unknown, never, never>,
    limit = 500,
  ) {
    const items: A[] = [];
    for (let index = 1; items.length < limit; index++) {
      const { rows, more } = yield* readPage(input, schema, index);
      items.push(...rows);
      if (!more) return { items, truncated: false };
    }
    return { items, truncated: true };
  });
  const write = (input: ForgejoCli.ForgejoApiInput) => request(input).pipe(Effect.asVoid);
  const getPull = (input: ProviderRepositoryRef & { readonly number: number }) =>
    read(
      {
        cwd: input.cwd,
        repository: input.repository,
        host: input.host,
        path: pullPath(input),
      },
      ForgejoPullRequest,
    );
  const getRepo = (input: ProviderRepositoryRef) =>
    read({ ...input, path: repoPath(input) }, ForgejoRepository);
  const getViewer = (input: {
    readonly cwd: string;
    readonly repository?: string;
    readonly host?: string;
  }) => read({ ...input, path: "user" }, ForgejoUser).pipe(Effect.map((user) => user.login));
  const permissions = (
    repo: typeof ForgejoRepository.Type,
    pr: typeof ForgejoPullRequest.Type,
    viewer: string,
  ): PullRequestViewerPermissions => {
    const canWrite = repo.permissions?.push ?? false;
    const canEdit = canWrite || pr.user?.login === viewer;
    const active = !repo.archived;
    return {
      actions: active
        ? CAPABILITIES.actions.filter((action) =>
            action === "merge" || action === "update-branch" ? canWrite : canEdit,
          )
        : [],
      comment: active && (!pr.is_locked || canWrite),
      resolve: false,
      verdicts: active
        ? pr.user?.login === viewer
          ? ["comment"]
          : CAPABILITIES.review.verdicts
        : [],
      requestReviewers: active && canEdit,
      labels: active && canWrite,
      updateMethods:
        active && canWrite ? (repo.allow_rebase_update ? ["merge", "rebase"] : ["merge"]) : [],
    };
  };
  const getPermissions = Effect.fn("ForgejoPullRequestProvider.getPermissions")(function* (
    input: ProviderRepositoryRef & { readonly number: number },
  ) {
    const [repo, pr, viewer] = yield* Effect.all(
      [getRepo(input), getPull(input), getViewer(input)],
      { concurrency: 3 },
    );
    return permissions(repo, pr, viewer);
  });
  const readChecks = Effect.fn("ForgejoPullRequestProvider.readChecks")(function* (
    input: ProviderRepositoryRef,
    pr: typeof ForgejoPullRequest.Type,
  ) {
    const branch = read(
      {
        ...input,
        path: `${repoPath(input)}/branches/${pr.base.ref.split("/").map(encodeURIComponent).join("/")}`,
      },
      ForgejoBranchStatusChecks,
    ).pipe(
      Effect.catchTags({
        PullRequestProviderError: (error) => {
          if (
            isForgejoCliError(error.cause) &&
            (error.cause.reason === "forbidden" || error.cause.reason === "not-found")
          ) {
            return Effect.succeed({});
          }
          return Effect.fail(error);
        },
      }),
    );
    const [statuses, policy] = yield* Effect.all(
      [
        page(
          {
            ...input,
            path: `${repoPath(input)}/statuses/${encodeURIComponent(pr.head.sha)}?sort=recentupdate`,
          },
          ForgejoStatus,
        ),
        branch,
      ],
      { concurrency: 2 },
    );
    return markRequiredForgejoChecks(forgejoChecks(statuses.items, pr.html_url), policy);
  });
  const unsupported = (operation: string) =>
    Effect.fail(failure(operation, `Forgejo does not expose ${operation} through its API.`));
  const provider: PullRequestProviderApi = {
    kind: SourceControlProviderKind.make("forgejo"),
    capabilities: CAPABILITIES,
    unavailableRequirement: UNAVAILABLE_REQUIREMENT,
    readsPublicHostWithoutCheckout: true,
    getViewer,
    listChangeRequests: Effect.fn("ForgejoPullRequestProvider.listChangeRequests")(
      function* (input) {
        const offset = input.cursor?.delivered ?? 0;
        const items: ReturnType<typeof forgejoChangeRequest>[] = [];
        const state = input.state === "merged" ? "closed" : input.state;
        const params = new URLSearchParams({ state, sort: "recentupdate" });
        const filters = input.filters;
        // Several `labels` match a pull request holding any of them but list it once per label it
        // holds, which would throw the row offset off, so one required label is all Forgejo is
        // asked for. The service narrows the rest.
        const single = filters?.labels?.find((group) => group.length === 1)?.[0];
        if (single !== undefined) {
          const labels = yield* page({ ...input, path: `${repoPath(input)}/labels` }, ForgejoLabel);
          const label = labels.items.find(
            (candidate) => candidate.name.toLowerCase() === single.trim().toLowerCase(),
          );
          if (label !== undefined) params.set("labels", String(label.id));
        }
        if (filters?.author !== undefined)
          params.set("poster", resolvePullRequestAuthorFilter(filters.author, input.viewer));
        const query = { ...input, path: `${repoPath(input)}/pulls?${params}` };
        // Self-hosted servers may cap pages below 50. Establish their actual page size before
        // translating the service's row offset into an API page number.
        const first = yield* readPage(query, Schema.NullOr(ForgejoPullRequest), 1).pipe(
          Effect.catchTags({
            // Forgejo answers a `poster` naming no account with a 400: nobody to list for.
            PullRequestProviderError: (error) =>
              params.has("poster") &&
              isForgejoCliError(error.cause) &&
              error.cause.httpStatus === 400
                ? Effect.succeed(null)
                : Effect.fail(error),
          }),
        );
        if (first === null) return { items: [], truncated: false, continues: false };
        const pageSize = first.rows.length || 50;
        const firstIndex = Math.floor(offset / pageSize) + 1;
        let consumed = 0;
        let more = true;
        // Forgejo has no `merged` list state: `state=closed` returns merged and
        // closed-unmerged rows alike, so rows are filtered by their mapped state and
        // only matching rows count toward the requested limit.
        for (let index = firstIndex; more && items.length < input.limit; index++) {
          const result =
            index === 1 ? first : yield* readPage(query, Schema.NullOr(ForgejoPullRequest), index);
          const rows = result.rows;
          const start = index === firstIndex ? offset % pageSize : 0;
          const countBefore = consumed;
          for (const row of rows.slice(start)) {
            if (items.length >= input.limit) break;
            consumed++;
            if (!row) continue;
            const changeRequest = forgejoChangeRequest(row);
            if (input.state !== "all" && changeRequest.state !== input.state) continue;
            items.push(changeRequest);
          }
          more = result.more || rows.length - start > consumed - countBefore;
        }
        return { items, truncated: more, continues: true, cursorAdvance: consumed };
      },
    ),
    getChangeRequestPreview: (input) => getPull(input).pipe(Effect.map(forgejoChangeRequest)),
    getChangeRequestSummary: (input) => getPull(input).pipe(Effect.map(forgejoChangeRequest)),
    getChangeRequestChecks: Effect.fn("ForgejoPullRequestProvider.getChangeRequestChecks")(
      function* (input) {
        const pr = yield* getPull(input);
        return { state: forgejoChangeRequest(pr).state, checks: yield* readChecks(input, pr) };
      },
    ),
    getChangeRequest: Effect.fn("ForgejoPullRequestProvider.getChangeRequest")(function* (input) {
      const [pr, repo, viewer] = yield* Effect.all(
        [getPull(input), getRepo(input), getViewer(input)],
        { concurrency: 3 },
      );
      const checks = yield* readChecks(input, pr);
      return {
        ...forgejoChangeRequest(pr),
        headSha: pr.head.sha,
        body: pr.body ?? "",
        changedFiles: pr.changed_files ?? 0,
        reviewers: (pr.requested_reviewers ?? []).flatMap((user) => {
          const actor = forgejoActor(user);
          return actor ? [actor] : [];
        }),
        checks,
        baseComparison: !pr.merge_base
          ? "unknown"
          : pr.merge_base === pr.base.sha
            ? "up-to-date"
            : "behind",
        viewerPermissions: permissions(repo, pr, viewer),
        mergeCapabilities: {
          merge: repo.allow_merge_commits ?? true,
          squash: repo.allow_squash_merge ?? true,
          rebase: repo.allow_rebase ?? true,
        },
      } satisfies ProviderChangeRequestDetail;
    }),
    getViewerPermissions: getPermissions,
    getChangeRequestActivity: Effect.fn("ForgejoPullRequestProvider.getChangeRequestActivity")(
      function* (input) {
        const [comments, reviews, commits, reactions, viewer] = yield* Effect.all(
          [
            // Issue comments ignore page/limit; fetch this unpaginated endpoint once.
            readArray({ ...input, path: `${issuePath(input)}/comments` }, ForgejoComment).pipe(
              Effect.map((items) => ({
                items: items.slice(0, 500),
                truncated: items.length > 500,
              })),
            ),
            page({ ...input, path: `${pullPath(input)}/reviews` }, ForgejoReview),
            // Commit file lists can exceed the output limit on large merges.
            page(
              { ...input, path: `${pullPath(input)}/commits?files=false&verification=false` },
              ForgejoCommit,
            ),
            page({ ...input, path: `${issuePath(input)}/reactions` }, ForgejoReaction),
            getViewer(input),
          ],
          { concurrency: 5 },
        );
        const reviewComments = yield* Effect.forEach(
          reviews.items.filter((review) => review.comments_count > 0 && review.state !== "PENDING"),
          (review) =>
            readArray(
              { ...input, path: `${pullPath(input)}/reviews/${review.id}/comments` },
              ForgejoReviewComment,
            ),
          { concurrency: 4 },
        );
        const allInline = reviewComments.flat();
        const inline = allInline.slice(0, 500);
        const entries = [
          ...comments.items.map((comment) => ({
            comment: forgejoComment(comment),
            reactionId: String(comment.id),
          })),
          ...reviews.items
            .filter((review) => review.state !== "PENDING" && review.state !== "REQUEST_REVIEW")
            .map((review) => ({
              comment: forgejoReview(review),
              reactionId: reviewCommentId(review),
            })),
          ...inline.map((comment) => ({
            comment: {
              ...forgejoComment(comment),
              kind: "review-comment" as const,
              path: comment.path,
            },
            reactionId: String(comment.id),
          })),
        ];
        const enriched = yield* Effect.forEach(
          entries,
          ({ comment, reactionId }) =>
            (reactionId === undefined
              ? Effect.succeed([])
              : readArray(
                  { ...input, path: `${repoPath(input)}/issues/comments/${reactionId}/reactions` },
                  ForgejoReaction,
                )
            ).pipe(
              Effect.map((rows) => ({ ...comment, reactions: forgejoReactions(rows, viewer) })),
            ),
          { concurrency: 4 },
        );
        const byId = new Map(enriched.map((comment) => [comment.id, comment]));
        const timeline = enriched.toSorted((a, b) => a.createdAt.localeCompare(b.createdAt));
        return {
          comments: timeline,
          commentCount: timeline.length,
          commentsTruncated:
            comments.truncated || reviews.truncated || allInline.length > inline.length,
          reviewThreads: inline.map((comment) => ({
            ...forgejoReviewThread(comment),
            comments: [byId.get(String(comment.id)) ?? forgejoComment(comment)],
          })),
          commits: commits.items.map(forgejoCommit),
          reactions: forgejoReactions(reactions.items, viewer),
        };
      },
    ),
    getFileRevisions: Effect.fn("ForgejoPullRequestProvider.getFileRevisions")(function* (input) {
      const result = yield* request({ ...input, path: `${pullPath(input)}.diff` });
      if (result.stdoutTruncated) {
        return yield* failure("getFileRevisions", "Forgejo diff exceeded the output limit.");
      }
      const revisions = new Map(parseDiffFileRevisions(result.stdout));
      for (const path of input.paths) {
        if (!revisions.has(path)) revisions.set(path, "");
      }
      return { revisions, complete: true };
    }),
    getDiff: (input) =>
      request({
        ...input,
        path: input.commit
          ? `${repoPath(input)}/git/commits/${encodeURIComponent(input.commit)}.diff`
          : `${pullPath(input)}.diff`,
      }).pipe(
        Effect.map((result) => ({
          patch: result.stdout,
          truncated: result.stdoutTruncated,
          nextCursor: null,
        })),
      ),
    getDiffFileContents: Effect.fn("ForgejoPullRequestProvider.getDiffFileContents")(
      function* (input) {
        const pr = yield* getPull(input);
        const commit = input.commit
          ? yield* read(
              {
                ...input,
                path: `${repoPath(input)}/git/commits/${encodeURIComponent(input.commit)}?files=false&verification=false`,
              },
              ForgejoCommit,
            )
          : null;
        const oldRef = commit ? commit.parents[0]?.sha : pr.merge_base || pr.base.sha;
        const newRef = input.commit ?? pr.head.sha;
        const content = (repository: string, ref: string, path: string) =>
          read(
            {
              ...input,
              repository,
              path: `${repoPath({ ...input, repository })}/contents/${path.split("/").map(encodeURIComponent).join("/")}?ref=${encodeURIComponent(ref)}`,
            },
            Schema.Struct({ content: Schema.String, encoding: Schema.Literal("base64") }),
          ).pipe(Effect.map((file) => Buffer.from(file.content, "base64").toString("utf8")));
        const [oldContents, newContents] = yield* Effect.all(
          [
            input.changeType === "new" || !oldRef
              ? Effect.succeed("")
              : content(input.repository, oldRef, input.oldPath),
            input.changeType === "deleted"
              ? Effect.succeed("")
              : content(pr.head.repo?.full_name ?? input.repository, newRef, input.newPath),
          ],
          { concurrency: 2 },
        );
        return { oldContents, newContents };
      },
    ),
    runAction: (input) => {
      switch (input.action) {
        case "merge":
          return Effect.gen(function* () {
            const deleteBranch = (yield* getRepo(input)).default_delete_branch_after_merge ?? false;
            yield* write({
              ...input,
              path: `${pullPath(input)}/merge`,
              method: "POST",
              body: { Do: input.mergeMethod ?? "merge", delete_branch_after_merge: deleteBranch },
            }).pipe(
              Effect.catchTags({
                // Forgejo merges before deleting the branch, so a refused deletion still merged.
                PullRequestProviderError: (error) =>
                  deleteBranch
                    ? getPull(input).pipe(
                        Effect.mapError(() => error),
                        Effect.flatMap((pr) => (pr.merged ? Effect.void : Effect.fail(error))),
                      )
                    : Effect.fail(error),
              }),
            );
          });
        case "close":
        case "reopen":
          return request({
            ...input,
            path: pullPath(input),
            method: "PATCH",
            body: { state: input.action === "close" ? "closed" : "open" },
          }).pipe(Effect.map((result) => forgejoActionSummary(result.stdout)));
        case "update-branch":
          return write({
            ...input,
            path: `${pullPath(input)}/update?style=${input.updateMethod ?? "merge"}`,
            method: "POST",
          });
        default:
          return unsupported(input.action);
      }
    },
    updateChangeRequest: (input) =>
      write({
        ...input,
        path: pullPath(input),
        method: "PATCH",
        body: {
          ...(input.title === undefined ? {} : { title: input.title }),
          ...(input.body === undefined ? {} : { body: input.body }),
        },
      }),
    comment: (input) =>
      write({
        ...input,
        path: `${issuePath(input)}/comments`,
        method: "POST",
        body: { body: input.body },
      }),
    updateComment: (input) =>
      write({
        ...input,
        path: `${repoPath(input)}/issues/comments/${encodeURIComponent(input.commentId)}`,
        method: "PATCH",
        body: { body: input.body },
      }),
    submitReview: Effect.fn("ForgejoPullRequestProvider.submitReview")(function* (input) {
      const pr = yield* getPull(input);
      yield* write({
        ...input,
        path: `${pullPath(input)}/reviews`,
        method: "POST",
        body: {
          event:
            input.verdict === "approve"
              ? "APPROVED"
              : input.verdict === "request-changes"
                ? "REQUEST_CHANGES"
                : "COMMENT",
          body: input.body,
          commit_id: pr.head.sha,
          comments: input.comments.map((comment) => {
            const position = comment.position;
            const old =
              position.kind === "deleted" ||
              (position.kind === "context" && position.side === "left");
            return {
              path: old ? (comment.oldPath ?? comment.path) : comment.path,
              body: comment.body,
              old_position: old ? position.oldLine : 0,
              new_position: old ? 0 : position.newLine,
            };
          }),
        },
      });
    }),
    listReviewerCandidates: Effect.fn("ForgejoPullRequestProvider.listReviewerCandidates")(
      function* (input) {
        // Unpaginated in Forgejo: paging it returns the full list on every page.
        const [pr, users] = yield* Effect.all(
          [
            getPull(input),
            readArray({ ...input, path: `${repoPath(input)}/assignees` }, ForgejoUser),
          ],
          { concurrency: 2 },
        );
        return {
          candidates: users
            .filter((user) => user.login !== pr.user?.login)
            .flatMap((user) => {
              const actor = forgejoActor(user);
              return actor
                ? [
                    {
                      ...actor,
                      id: user.login,
                      kind: "user" as const,
                      isRequested:
                        pr.requested_reviewers?.some((reviewer) => reviewer.login === user.login) ??
                        false,
                    },
                  ]
                : [];
            }),
          truncated: false,
        };
      },
    ),
    setReviewerRequest: (input) =>
      write({
        ...input,
        path: `${pullPath(input)}/requested_reviewers`,
        method: input.requested ? "POST" : "DELETE",
        body: { reviewers: input.reviewers.map((reviewer) => reviewer.id) },
      }),
    listLabelCandidates: Effect.fn("ForgejoPullRequestProvider.listLabelCandidates")(
      function* (input) {
        const [pr, labels] = yield* Effect.all(
          [getPull(input), page({ ...input, path: `${repoPath(input)}/labels` }, ForgejoLabel)],
          { concurrency: 2 },
        );
        return {
          candidates: labels.items.map((label) => ({
            name: label.name,
            color: label.color ?? null,
            description: label.description ?? null,
            isApplied: pr.labels?.some((applied) => applied.id === label.id) ?? false,
          })),
          truncated: labels.truncated,
        };
      },
    ),
    listRepositoryLabels: Effect.fn("ForgejoPullRequestProvider.listRepositoryLabels")(
      function* (input) {
        const labels = yield* page({ ...input, path: `${repoPath(input)}/labels` }, ForgejoLabel);
        return {
          items: labels.items.map((label) => ({ name: label.name, color: label.color ?? null })),
          truncated: labels.truncated,
        };
      },
    ),
    searchRepositoryAuthors: Effect.fn("ForgejoPullRequestProvider.searchRepositoryAuthors")(
      function* (input) {
        const query = input.query?.trim() ?? "";
        const actors = (users: ReadonlyArray<typeof ForgejoUser.Type>) =>
          users.flatMap((user) => {
            const actor = forgejoActor(user);
            return actor ? [actor] : [];
          });
        // Before anything is typed the repository's own people stand in; a search reaches
        // contributors from forks, who are never assignable.
        if (query.length === 0) {
          const users = yield* readArray(
            { ...input, path: `${repoPath(input)}/assignees` },
            ForgejoUser,
          );
          return { items: actors(users), truncated: false };
        }
        const found = yield* readLinked(
          {
            ...input,
            path: `users/search?${new URLSearchParams({ q: query, limit: String(USER_SEARCH_LIMIT) })}`,
          },
          ForgejoUserSearch,
        );
        const users = found.value.data ?? [];
        // A server may cap pages below the limit asked for; its `link` header still says more.
        return {
          items: actors(users),
          truncated: found.next || users.length >= USER_SEARCH_LIMIT,
        };
      },
    ),
    setLabels: Effect.fn("ForgejoPullRequestProvider.setLabels")(function* (input) {
      const labels = yield* page({ ...input, path: `${repoPath(input)}/labels` }, ForgejoLabel);
      const selected = labels.items.filter((label) => input.labels.includes(label.name));
      if (selected.length !== input.labels.length)
        return yield* failure("setLabels", "One or more requested labels could not be found.");
      if (input.applied)
        yield* write({
          ...input,
          path: `${issuePath(input)}/labels`,
          method: "POST",
          body: { labels: selected.map((label) => label.id) },
        });
      else
        yield* Effect.forEach(
          selected,
          (label) =>
            write({ ...input, path: `${issuePath(input)}/labels/${label.id}`, method: "DELETE" }),
          { concurrency: 1 },
        );
    }),
    setReaction: Effect.fn("ForgejoPullRequestProvider.setReaction")(function* (input) {
      let commentId = input.subjectId;
      if (commentId?.startsWith("review:")) {
        const reviewId = /^review:([1-9]\d*)$/.exec(commentId)?.[1];
        if (!reviewId) return yield* failure("setReaction", "Invalid Forgejo review ID.");
        const review = yield* read(
          { ...input, path: `${pullPath(input)}/reviews/${reviewId}` },
          ForgejoReview,
        );
        commentId = reviewCommentId(review);
        if (!commentId)
          return yield* failure(
            "setReaction",
            "Forgejo did not return a comment ID for this review.",
          );
      }
      if (commentId && !/^[1-9]\d*$/.test(commentId))
        return yield* failure("setReaction", "Invalid Forgejo comment ID.");
      yield* write({
        ...input,
        path: commentId
          ? `${repoPath(input)}/issues/comments/${commentId}/reactions`
          : `${issuePath(input)}/reactions`,
        method: input.reacted ? "POST" : "DELETE",
        body: { content: FORGEJO_REACTIONS[input.content] },
      });
    }),
    replyToThread: () => unsupported("thread replies"),
    setThreadResolution: () => unsupported("thread resolution"),
  };
  return provider;
});