@kernel-sig/console 0.1.0

package/backend/app/services/sync_service.py

@@ -0,0 +1,752 @@
+"""数据同步服务。
+
+把 AtomGit 的 PR / Issue 拉取到本地。
+
+同步策略（分层，控制 API 调用量）：
+- L1 列表：拉取 PR/Issue 列表，更新标题、状态、标签等轻量字段
+- L2 详情：仅对内容发生变化的 PR 拉取提交与文件
+- L3 评论：仅在评论数增加时拉取，用于解析评审事件
+
+实测 open PR 逾 1100 个，每次全量拉详情需 2000+ 请求，
+会迅速耗尽上游配额，因此必须按变化驱动而非每次都拉全量。
+
+幂等性：所有写入以 (repository_id, number) 为冲突键做 upsert，
+并以 AtomGit 的 updated_at 做乐观并发控制 —— 仅当远端更新时才覆盖本地。
+"""
+
+import hashlib
+import uuid
+from datetime import UTC, datetime, timedelta
+
+import structlog
+from sqlalchemy import func, select
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.config import Settings
+from app.core.exceptions import ValidationError
+from app.domain.review import derive_gate, parse_events
+from app.integrations.atomgit.client import AtomGitClient, AtomGitError
+from app.integrations.atomgit.models import AtomGitIssue, AtomGitPullRequest
+from app.models.issue import Issue
+from app.models.pull_request import (
+    PRComment,
+    PRCommit,
+    PRFile,
+    PRState,
+    PullRequest,
+    ReviewEvent,
+    ReviewEventSource,
+)
+from app.models.repository import (
+    Repository,
+    SyncResource,
+    SyncRun,
+    SyncStatus,
+    SyncTrigger,
+)
+from app.services import credential_service, repository_service
+
+logger = structlog.get_logger(__name__)
+
+# 单次同步最多拉取的页数，防止配置错误导致无限翻页
+MAX_PAGES = 40
+
+
+def content_hash(*parts: str | None) -> str:
+    """内容指纹。用于判断是否需要重新触发 AI 分析等昂贵操作。"""
+    digest = hashlib.sha256()
+    for part in parts:
+        digest.update((part or "").encode("utf-8"))
+        digest.update(b"\x00")
+    return digest.hexdigest()
+
+
+def _pr_state(value: str) -> PRState:
+    try:
+        return PRState(value)
+    except ValueError:
+        return PRState.OPEN
+
+
+def _dedupe_by(items: list, *, key) -> list:
+    """按 key 去重，保留首次出现。
+
+    上游的提交列表会返回重复的 SHA —— 实测 PR #19344 的 9 条提交里有 2 条
+    重复（分支被 force-push 或含合并提交时出现）。而 (pull_request_id, sha)
+    上有唯一约束，直接整批插入会撞约束并让整个同步批次失败。
+    保留首次出现即可：重复项指向同一个提交，信息完全相同。
+    """
+    seen: set = set()
+    result = []
+    for item in items:
+        value = key(item)
+        if value in seen:
+            continue
+        seen.add(value)
+        result.append(item)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Pull Request
+# ---------------------------------------------------------------------------
+
+
+def _pull_row(repository_id: uuid.UUID, pr: AtomGitPullRequest) -> dict:
+    gate = derive_gate(pr.label_names, is_draft=pr.draft, state=pr.state)
+    return {
+        "id": uuid.uuid4(),
+        "repository_id": repository_id,
+        "number": pr.number,
+        "title": pr.title,
+        "body": pr.body,
+        "state": _pr_state(pr.state).value,
+        "draft": pr.draft,
+        "author_login": pr.author_login,
+        "author_name": pr.user.name if pr.user else None,
+        "author_avatar_url": pr.user.avatar_url if pr.user else None,
+        "source_branch": pr.source_branch,
+        "target_branch": pr.target_branch,
+        "labels": [label.model_dump(mode="json") for label in pr.labels],
+        "label_names": pr.label_names,
+        "added_lines": pr.added_lines,
+        "removed_lines": pr.removed_lines,
+        "comments_count": pr.notes,
+        "mergeable": pr.mergeable,
+        "merge_conflict": pr.has_merge_conflict,
+        "merge_check_detail": (
+            pr.mergeable_state.model_dump(mode="json") if pr.mergeable_state else None
+        ),
+        "gate_stage": gate.stage.value,
+        "atomgit_created_at": pr.created_at,
+        "atomgit_updated_at": pr.updated_at,
+        "merged_at": pr.merged_at,
+        "closed_at": pr.closed_at,
+        "html_url": pr.permalink,
+        "last_synced_at": datetime.now(UTC),
+        "content_hash": content_hash(pr.title, pr.body, ",".join(sorted(pr.label_names))),
+    }
+
+
+_UPSERT_UPDATE_COLUMNS = (
+    "title",
+    "body",
+    "state",
+    "draft",
+    "author_login",
+    "author_name",
+    "author_avatar_url",
+    "source_branch",
+    "target_branch",
+    "labels",
+    "label_names",
+    "added_lines",
+    "removed_lines",
+    "comments_count",
+    "mergeable",
+    "merge_conflict",
+    "merge_check_detail",
+    "gate_stage",
+    "atomgit_created_at",
+    "atomgit_updated_at",
+    "merged_at",
+    "closed_at",
+    "html_url",
+    "last_synced_at",
+    "content_hash",
+)
+
+
+async def upsert_pulls(
+    session: AsyncSession, repository: Repository, pulls: list[AtomGitPullRequest]
+) -> tuple[int, int]:
+    """写入 PR 列表，返回 (新增数, 更新数)。
+
+    以 (repository_id, number) 为冲突键。冲突时仅当远端 updated_at
+    不早于本地值才覆盖 —— 防止并发同步时用旧数据覆盖新数据。
+    """
+    if not pulls:
+        return 0, 0
+
+    numbers = [p.number for p in pulls]
+    existing = set(
+        (
+            await session.scalars(
+                select(PullRequest.number).where(
+                    PullRequest.repository_id == repository.id,
+                    PullRequest.number.in_(numbers),
+                )
+            )
+        ).all()
+    )
+
+    rows = [_pull_row(repository.id, pr) for pr in pulls]
+
+    stmt = pg_insert(PullRequest).values(rows)
+    update_set = {col: getattr(stmt.excluded, col) for col in _UPSERT_UPDATE_COLUMNS}
+    # 仅当内容指纹变化时才重新拉详情 —— 这是把详情同步量从"每轮全部 PR"
+    # 降到"每轮仅变化项"的关键
+    update_set["needs_detail"] = stmt.excluded.content_hash.is_distinct_from(
+        PullRequest.content_hash
+    )
+    stmt = stmt.on_conflict_do_update(
+        constraint="uq_ksp_pull_request_repo_number",
+        set_=update_set,
+        where=PullRequest.atomgit_updated_at.is_(None)
+        | (stmt.excluded.atomgit_updated_at >= PullRequest.atomgit_updated_at),
+    )
+    await session.execute(stmt)
+
+    created = sum(1 for n in numbers if n not in existing)
+    return created, len(numbers) - created
+
+
+async def upsert_issues(
+    session: AsyncSession, repository: Repository, issues: list[AtomGitIssue]
+) -> tuple[int, int]:
+    if not issues:
+        return 0, 0
+
+    numbers = [i.number for i in issues]
+    existing = set(
+        (
+            await session.scalars(
+                select(Issue.number).where(
+                    Issue.repository_id == repository.id, Issue.number.in_(numbers)
+                )
+            )
+        ).all()
+    )
+
+    rows = [
+        {
+            "id": uuid.uuid4(),
+            "repository_id": repository.id,
+            "number": issue.number,
+            "title": issue.title,
+            "body": issue.body,
+            "state": issue.state,
+            "issue_type": issue.issue_type,
+            "issue_state": issue.issue_state,
+            "priority": issue.priority,
+            "priority_label": issue.priority_label,
+            "author_login": issue.user.login if issue.user else None,
+            "assignee_login": issue.assignee.login if issue.assignee else None,
+            "labels": [label.model_dump(mode="json") for label in issue.labels],
+            "label_names": issue.label_names,
+            "comments_count": issue.comments,
+            "atomgit_created_at": issue.created_at,
+            "atomgit_updated_at": issue.updated_at,
+            "finished_at": issue.finished_at,
+            "html_url": issue.html_url,
+            "last_synced_at": datetime.now(UTC),
+            "content_hash": content_hash(issue.title, issue.body, issue.issue_state),
+        }
+        for issue in issues
+    ]
+
+    stmt = pg_insert(Issue).values(rows)
+    update_columns = (
+        "title",
+        "body",
+        "state",
+        "issue_type",
+        "issue_state",
+        "priority",
+        "priority_label",
+        "assignee_login",
+        "labels",
+        "label_names",
+        "comments_count",
+        "atomgit_updated_at",
+        "finished_at",
+        "html_url",
+        "last_synced_at",
+        "content_hash",
+    )
+    stmt = stmt.on_conflict_do_update(
+        constraint="uq_ksp_issue_repo_number",
+        set_={col: getattr(stmt.excluded, col) for col in update_columns},
+        where=Issue.atomgit_updated_at.is_(None)
+        | (stmt.excluded.atomgit_updated_at >= Issue.atomgit_updated_at),
+    )
+    await session.execute(stmt)
+
+    created = sum(1 for n in numbers if n not in existing)
+    return created, len(numbers) - created
+
+
+# ---------------------------------------------------------------------------
+# PR 详情：提交、文件、评审事件
+# ---------------------------------------------------------------------------
+
+
+async def sync_pull_detail(
+    session: AsyncSession, client: AtomGitClient, repository: Repository, pull: PullRequest
+) -> None:
+    """拉取单个 PR 的提交、变更文件，并解析评审事件。
+
+    评审事件由标签与评论共同推导 —— 评审人身份只存在于评论中，
+    标签仅给出汇总结果。
+    """
+    owner, name = repository.owner, repository.name
+
+    commits = await client.get_pull_commits(owner, name, pull.number)
+    files = await client.get_pull_files(owner, name, pull.number)
+    comments = await client.get_pull_comments(owner, name, pull.number)
+
+    commits = _dedupe_by(commits, key=lambda commit: commit.sha)
+    files = _dedupe_by(files, key=lambda file: file.filename)
+
+    # --- 提交：整批替换，避免处理"已从 PR 中移除的提交"这类脏数据 ---
+    await session.execute(PRCommit.__table__.delete().where(PRCommit.pull_request_id == pull.id))
+    session.add_all(
+        [
+            PRCommit(
+                pull_request_id=pull.id,
+                sha=commit.sha,
+                sequence=index,
+                subject=commit.subject,
+                message=commit.message,
+                author_name=(commit.commit.author.name if commit.commit.author else None),
+                author_email=commit.author_email,
+                committed_at=commit.commit.author.date if commit.commit.author else None,
+                signed_off_bys=_extract_signed_off_bys(commit.message),
+            )
+            for index, commit in enumerate(commits, start=1)
+        ]
+    )
+
+    # --- 变更文件：同样整批替换 ---
+    await session.execute(PRFile.__table__.delete().where(PRFile.pull_request_id == pull.id))
+    session.add_all(
+        [
+            PRFile(
+                pull_request_id=pull.id,
+                filename=file.filename,
+                status=file.status,
+                additions=file.additions,
+                deletions=file.deletions,
+                is_binary=file.is_binary,
+                too_large=bool(file.patch and file.patch.too_large),
+                diff=file.diff_text,
+            )
+            for file in files
+        ]
+    )
+    pull.changed_files = len(files)
+
+    # --- 评论原文：留存并展示 ---
+    #
+    # 评审意见、维护者的提问、以及 openEuler 机器人自动生成的变更摘要与
+    # 代码审查结论，都只存在于评论里。此前这些内容被解析成评审事件后即丢弃，
+    # 界面上无从看到讨论过程，维护者必须跳回 AtomGit 才能读懂评审意见。
+    #
+    # 用 upsert 而非整批替换：评论可以被编辑，但不该因为一次拉取失败就消失。
+    if comments:
+        stmt = pg_insert(PRComment).values(
+            [
+                {
+                    "pull_request_id": pull.id,
+                    "comment_id": str(comment.id),
+                    "comment_type": comment.comment_type,
+                    "discussion_id": (
+                        str(comment.discussion_id) if comment.discussion_id else None
+                    ),
+                    "author_login": comment.author_login or "",
+                    "author_avatar_url": comment.user.avatar_url if comment.user else None,
+                    "body": comment.body or "",
+                    "atomgit_created_at": comment.created_at,
+                    "atomgit_updated_at": comment.updated_at,
+                    "last_synced_at": datetime.now(UTC),
+                }
+                for comment in comments
+            ]
+        )
+        stmt = stmt.on_conflict_do_update(
+            constraint="uq_ksp_pr_comment_identity",
+            set_={
+                column: getattr(stmt.excluded, column)
+                for column in (
+                    "body",
+                    "author_login",
+                    "author_avatar_url",
+                    "comment_type",
+                    "discussion_id",
+                    "atomgit_updated_at",
+                    "last_synced_at",
+                )
+            },
+        )
+        await session.execute(stmt)
+
+    # --- 评审事件：只持久化评论派生的部分 ---
+    #
+    # 标签代表"当前状态"，评论代表"历史事实"，两者语义不同：
+    # 标签本身没有时间戳，任何合成的时间（如用 updated_at）都会随每次同步变化，
+    # 导致唯一约束失效、同一标签被反复写入。而评论带有真实且稳定的时间戳，
+    # 且已包含评审人身份与动作时刻 —— 评审工作量与 SLA 所需的全部信息都在这里。
+    #
+    # 当前门禁状态不落库，由 derive_gate 从 label_names 实时推导（见 domain/review.py）。
+    events = parse_events(
+        labels=[],
+        comments=[
+            (comment.body, comment.author_login or "", comment.created_at)
+            for comment in comments
+            if comment.created_at is not None
+        ],
+    )
+    for event in events:
+        await session.execute(
+            pg_insert(ReviewEvent)
+            .values(
+                pull_request_id=pull.id,
+                event_type=event.event_type.value,
+                actor_login=event.actor_login,
+                source=ReviewEventSource(event.source).value,
+                raw_payload={"raw": event.raw},
+                occurred_at=event.occurred_at,
+            )
+            .on_conflict_do_nothing(constraint="uq_ksp_review_event_identity")
+        )
+
+    pull.detail_synced_at = datetime.now(UTC)
+    pull.needs_detail = False
+
+
+def _extract_signed_off_bys(message: str) -> list[str]:
+    """提取 Signed-off-by 链。openEuler 要求该链完整。"""
+    result: list[str] = []
+    for line in message.splitlines():
+        stripped = line.strip()
+        lowered = stripped.lower()
+        if lowered.startswith("signed-off-by:"):
+            result.append(stripped.split(":", 1)[1].strip())
+    return result
+
+
+async def pulls_needing_detail(
+    session: AsyncSession, repository_id: uuid.UUID, *, limit: int
+) -> list[PullRequest]:
+    """挑出需要拉详情的 PR：从未拉过的，或内容已变化的。
+
+    活跃 PR（open）优先于已合并的，保证维护者看到的是当前状态。
+    """
+    stmt = (
+        select(PullRequest)
+        .where(
+            PullRequest.repository_id == repository_id,
+            PullRequest.needs_detail.is_(True),
+        )
+        .order_by(
+            PullRequest.detail_synced_at.is_(None).desc(),
+            PullRequest.state.asc(),
+            PullRequest.atomgit_updated_at.desc(),
+        )
+        .limit(limit)
+    )
+    return list((await session.scalars(stmt)).all())
+
+
+# ---------------------------------------------------------------------------
+# 同步任务编排
+# ---------------------------------------------------------------------------
+
+
+async def _start_run(
+    session: AsyncSession,
+    repository: Repository,
+    resource: SyncResource,
+    trigger: SyncTrigger,
+) -> SyncRun:
+    run = SyncRun(
+        repository_id=repository.id,
+        resource=resource,
+        trigger=trigger,
+        status=SyncStatus.RUNNING,
+    )
+    session.add(run)
+    await session.flush()
+    return run
+
+
+async def _finish_run(
+    session: AsyncSession,
+    run: SyncRun,
+    *,
+    status: SyncStatus,
+    fetched: int = 0,
+    created: int = 0,
+    updated: int = 0,
+    failed: int = 0,
+    api_calls: int = 0,
+    error: str | None = None,
+) -> None:
+    run.status = status
+    run.finished_at = datetime.now(UTC)
+    run.items_fetched = fetched
+    run.items_created = created
+    run.items_updated = updated
+    run.items_failed = failed
+    run.api_calls = api_calls
+    run.error = error
+    await session.flush()
+
+
+def _skip_without_credential(repository: Repository) -> None:
+    """仓库还没配凭据时跳过同步，不留下任何记录。
+
+    这**不是**同步失败，而是"这个仓库还没启用"，状态由
+    ``repository.credential_id`` 是否为空表达就够 —— 界面据此提示去配凭据。
+
+    以前这里写一条 ``SyncRun(status=FAILED, error="仓库未配置凭据")``，
+    两个问题：一是定时任务每 10/30/5 分钟各跑一轮，一个没配凭据的仓库一天
+    能攒下几百条一模一样的失败记录，把 ``sync_runs`` 表淹掉；二是它 return
+    在 ``mark_synced`` 之前，``repository.last_sync_error`` 根本没被写入 ——
+    而界面上那块红框读的正是后者。等于留了噪音、却没有传递信息。
+    """
+    logger.debug("sync_skipped_without_credential", repository=repository.full_name)
+
+
+async def sync_pulls(
+    session: AsyncSession,
+    settings: Settings,
+    repository: Repository,
+    *,
+    trigger: SyncTrigger = SyncTrigger.SCHEDULED,
+    states: tuple[str, ...] = ("open", "merged"),
+) -> SyncRun | None:
+    """同步 PR 列表。未配置凭据时返回 None（跳过，见 ``_skip_without_credential``）。
+
+    默认同时同步 open 与 merged：维护者既要看当前待办，
+    也要看近期合入情况用于统计趋势。
+
+    ``repository.backfill_days`` 生效于此：列表按更新时间倒序返回，
+    一旦某页全部早于回填窗口，即可判定后续无需再拉 ——
+    否则已合并 PR 有上万个，会一路翻页到安全上限。
+    """
+    if repository.credential_id is None:
+        _skip_without_credential(repository)
+        return None
+
+    run = await _start_run(session, repository, SyncResource.PULLS, trigger)
+    credential = await credential_service.require_credential(session, repository.credential_id)
+
+    client = repository_service.build_client(settings, repository, credential)
+
+    cutoff = datetime.now(UTC) - timedelta(days=repository.backfill_days or 180)
+    fetched = created = updated = 0
+    error: str | None = None
+    status = SyncStatus.SUCCEEDED
+
+    try:
+        async with client:
+            for state in states:
+                async for page in client.iter_pulls(
+                    repository.owner, repository.name, state=state, per_page=100
+                ):
+                    c, u = await upsert_pulls(session, repository, page.items)
+                    fetched += len(page.items)
+                    created += c
+                    updated += u
+
+                    if page.items and all(
+                        item.updated_at is not None and item.updated_at < cutoff
+                        for item in page.items
+                    ):
+                        # 整页都已早于回填窗口，后续只会更旧
+                        logger.info(
+                            "sync_pulls_backfill_window_reached",
+                            repository=repository.full_name,
+                            state=state,
+                            page=page.page,
+                            cutoff_days=repository.backfill_days,
+                        )
+                        break
+
+                    if page.page >= MAX_PAGES:
+                        logger.warning(
+                            "sync_pulls_page_limit_reached",
+                            repository=repository.full_name,
+                            state=state,
+                        )
+                        status = SyncStatus.PARTIAL
+                        break
+    except AtomGitError as exc:
+        error = str(exc)
+        status = SyncStatus.FAILED if fetched == 0 else SyncStatus.PARTIAL
+        logger.warning("sync_pulls_failed", repository=repository.full_name, error=error)
+
+    await _finish_run(
+        session,
+        run,
+        status=status,
+        fetched=fetched,
+        created=created,
+        updated=updated,
+        api_calls=client.stats.requests,
+        error=error,
+    )
+    repository_service.mark_synced(repository, error=error)
+    return run
+
+
+async def sync_issues(
+    session: AsyncSession,
+    settings: Settings,
+    repository: Repository,
+    *,
+    trigger: SyncTrigger = SyncTrigger.SCHEDULED,
+    states: tuple[str, ...] = ("open",),
+) -> SyncRun | None:
+    """同步 Issue 列表。未配置凭据时返回 None（跳过，见 ``_skip_without_credential``）。"""
+    if repository.credential_id is None:
+        _skip_without_credential(repository)
+        return None
+
+    run = await _start_run(session, repository, SyncResource.ISSUES, trigger)
+    credential = await credential_service.require_credential(session, repository.credential_id)
+    client = repository_service.build_client(settings, repository, credential)
+
+    fetched = created = updated = 0
+    error: str | None = None
+    status = SyncStatus.SUCCEEDED
+
+    try:
+        async with client:
+            for state in states:
+                async for page in client.iter_issues(
+                    repository.owner, repository.name, state=state, per_page=100
+                ):
+                    c, u = await upsert_issues(session, repository, page.items)
+                    fetched += len(page.items)
+                    created += c
+                    updated += u
+                    if page.page >= MAX_PAGES:
+                        status = SyncStatus.PARTIAL
+                        break
+    except AtomGitError as exc:
+        error = str(exc)
+        status = SyncStatus.FAILED if fetched == 0 else SyncStatus.PARTIAL
+        logger.warning("sync_issues_failed", repository=repository.full_name, error=error)
+
+    await _finish_run(
+        session,
+        run,
+        status=status,
+        fetched=fetched,
+        created=created,
+        updated=updated,
+        api_calls=client.stats.requests,
+        error=error,
+    )
+    repository_service.mark_synced(repository, error=error)
+    return run
+
+
+async def sync_pull_details(
+    session: AsyncSession,
+    settings: Settings,
+    repository: Repository,
+    *,
+    limit: int = 50,
+    trigger: SyncTrigger = SyncTrigger.SCHEDULED,
+) -> SyncRun | None:
+    """为内容有变化的 PR 补齐提交、文件与评审事件。未配置凭据时返回 None。"""
+    if repository.credential_id is None:
+        _skip_without_credential(repository)
+        return None
+
+    run = await _start_run(session, repository, SyncResource.PULLS, trigger)
+    credential = await credential_service.require_credential(session, repository.credential_id)
+    client = repository_service.build_client(settings, repository, credential)
+
+    targets = await pulls_needing_detail(session, repository.id, limit=limit)
+    succeeded = failed = 0
+    error: str | None = None
+
+    try:
+        async with client:
+            for pull in targets:
+                try:
+                    # 每个 PR 一个保存点：写入失败时只回滚这一个 PR，
+                    # 外层事务仍可继续。否则一次约束冲突会污染整个事务，
+                    # 后续所有 PR 的写入都会跟着失败。
+                    async with session.begin_nested():
+                        await sync_pull_detail(session, client, repository, pull)
+                    succeeded += 1
+                except (AtomGitError, SQLAlchemyError) as exc:
+                    failed += 1
+                    logger.warning(
+                        "sync_pull_detail_failed",
+                        repository=repository.full_name,
+                        number=pull.number,
+                        error=str(exc)[:300],
+                    )
+                    # 单个 PR 失败不阻塞整体：记录后继续，下次同步会重试
+    except AtomGitError as exc:
+        error = str(exc)
+
+    status = (
+        SyncStatus.FAILED
+        if succeeded == 0 and failed > 0
+        else SyncStatus.PARTIAL
+        if failed > 0
+        else SyncStatus.SUCCEEDED
+    )
+
+    await _finish_run(
+        session,
+        run,
+        status=status,
+        fetched=len(targets),
+        updated=succeeded,
+        failed=failed,
+        api_calls=client.stats.requests,
+        error=error,
+    )
+    return run
+
+
+async def sync_repository(
+    session: AsyncSession,
+    settings: Settings,
+    repository: Repository,
+    *,
+    trigger: SyncTrigger = SyncTrigger.SCHEDULED,
+    detail_limit: int = 50,
+) -> list[SyncRun]:
+    """完整同步一个仓库：列表 → 详情。
+
+    这是用户点「立即同步」走的路径，所以无凭据时**明确报错**而不是像定时
+    任务那样静默跳过 —— 他正等着结果，得知道卡在哪一步。
+    """
+    if repository.credential_id is None:
+        raise ValidationError("仓库未配置凭据，请先在「设置 → 凭据」中添加 AtomGit token")
+
+    runs: list[SyncRun] = []
+    for run in (
+        await sync_pulls(session, settings, repository, trigger=trigger),
+        await sync_issues(session, settings, repository, trigger=trigger),
+        await sync_pull_details(
+            session, settings, repository, limit=detail_limit, trigger=trigger
+        ),
+    ):
+        # 无凭据在上面已经拦下，走不到 None 分支 —— 留着它是为了不让调用方
+        # 必须记住"跳过只可能发生在无凭据时"这个前提。
+        if run is not None:
+            runs.append(run)
+
+    await session.commit()
+    return runs
+
+
+async def count_pulls_by_state(session: AsyncSession, repository_id: uuid.UUID) -> dict[str, int]:
+    stmt = (
+        select(PullRequest.state, func.count())
+        .where(PullRequest.repository_id == repository_id)
+        .group_by(PullRequest.state)
+    )
+    return {row[0]: row[1] for row in (await session.execute(stmt)).all()}