perf(github): Cache accessible repos for accessibleOnly search (#112548)

## Summary

- The `OrganizationIntegrationReposEndpoint`
(`/integrations/{id}/repos/`) lets the frontend search for GitHub repos
available to a GitHub App installation. When called with
`accessibleOnly=true` and a search query (as the SCM onboarding repo
selector does on each debounced keystroke), the previous implementation
fetched all installation-accessible repos from the GitHub API (up to 50
pages of 100 = 5,000 repos) on every request, then filtered with a
Python list comprehension
- Cache the full repo list in `sentry.cache.default_cache` (Redis) for 5
minutes, and filter locally on subsequent requests — reducing each typed
query from O(pages) GitHub API calls to zero

## Test plan

- [ ] Existing `get_repositories` tests pass (6/6)
- [ ] New `test_get_repositories_accessible_only_caches_repos` verifies
cache hit path skips `/installation/repositories` calls
- [ ] Manual testing: second `accessibleOnly` search returns instantly
from cache

Refs VDY-68

Author: jaydgoss

src/sentry/integrations/api/endpoints/organization_integration_repos.py

@@ -72,7 +72,11 @@ def get(
             accessible_only = request.GET.get("accessibleOnly", "false").lower() == "true"
 
             try:
-                repositories = install.get_repositories(search, accessible_only=accessible_only)
+                repositories = install.get_repositories(
+                    search,
+                    accessible_only=accessible_only,
+                    use_cache=accessible_only and bool(search),
+                )
             except (IntegrationError, IdentityNotValid) as e:
                 return self.respond({"detail": str(e)}, status=400)
 

src/sentry/integrations/bitbucket/integration.py

@@ -137,6 +137,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         username = self.model.metadata.get("uuid", self.username)
         if not query:

src/sentry/integrations/bitbucket_server/integration.py

@@ -288,6 +288,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         if not query:
             resp = self.get_client().get_repos()

src/sentry/integrations/example/integration.py

@@ -154,6 +154,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         return [{"name": "repo", "identifier": "user/repo", "external_id": "1"}]
 

src/sentry/integrations/github/client.py

@@ -8,6 +8,7 @@
 
 import orjson
 import sentry_sdk
+from django.core.cache import cache
 from requests import PreparedRequest
 
 from sentry.constants import ObjectStatus
@@ -56,6 +57,14 @@
 JWT_AUTH_ROUTES = ("/app/installations", "access_tokens")
 
 
+class CachedRepo(TypedDict):
+    id: int
+    name: str
+    full_name: str
+    default_branch: str | None
+    archived: bool | None
+
+
 class GithubRateLimitInfo:
     def __init__(self, info: dict[str, int]) -> None:
         self.limit = info["limit"]
@@ -549,6 +558,33 @@ def get_repos(self, page_number_limit: int | None = None) -> list[dict[str, Any]
                 page_number_limit=page_number_limit,
             )
 
+    def get_repos_cached(self, ttl: int = 300) -> list[CachedRepo]:
+        """
+        Return all repos accessible to this installation, cached in
+        Django cache for ``ttl`` seconds.
+
+        Only the fields used by get_repositories() are stored to keep
+        the cache payload small.
+        """
+        cache_key = f"github:repos:{self.integration.id}"
+        cached = cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        all_repos = self.get_repos()
+        repos: list[CachedRepo] = [
+            {
+                "id": r["id"],
+                "name": r["name"],
+                "full_name": r["full_name"],
+                "default_branch": r.get("default_branch"),
+                "archived": r.get("archived"),
+            }
+            for r in all_repos
+        ]
+        cache.set(cache_key, repos, ttl)
+        return repos
+
     def search_repositories(self, query: bytes) -> Mapping[str, Sequence[Any]]:
         """
         Find repositories matching a query.

src/sentry/integrations/github/integration.py

@@ -2,7 +2,7 @@
 
 import logging
 import re
-from collections.abc import Callable, Mapping, MutableMapping, Sequence
+from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
 from dataclasses import dataclass
 from enum import StrEnum
 from typing import Any, NotRequired, TypedDict
@@ -325,46 +325,55 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         """
         args:
         * query - a query to filter the repositories by
         * accessible_only - when True with a query, fetch only installation-
           accessible repos and filter locally instead of using the Search API
           (which may return repos outside the installation's scope)
+        * use_cache - when True, serve repos from a short-lived cache instead
+          of re-fetching all pages from GitHub on every call
 
         This fetches all repositories accessible to the Github App
         https://docs.github.com/en/rest/apps/installations#list-repositories-accessible-to-the-app-installation
         """
-        if not query or accessible_only:
-            all_repos = self.get_client().get_repos(page_number_limit=page_number_limit)
-            repos: list[RepositoryInfo] = [
+        client = self.get_client()
+
+        def to_repo_info(raw_repos: Iterable[Mapping[str, Any]]) -> list[RepositoryInfo]:
+            return [
                 {
                     "name": i["name"],
                     "identifier": i["full_name"],
                     "external_id": self.get_repo_external_id(i),
                     "default_branch": i.get("default_branch"),
                 }
-                for i in all_repos
-                if not i.get("archived")
+                for i in raw_repos
             ]
-            if query:
-                query_lower = query.lower()
-                repos = [r for r in repos if query_lower in str(r["identifier"]).lower()]
-            return repos
 
+        def _get_all_repos():
+            if use_cache:
+                return client.get_repos_cached()
+            return client.get_repos(page_number_limit=page_number_limit)
+
+        if not query:
+            all_repos = _get_all_repos()
+            return to_repo_info(r for r in all_repos if not r.get("archived"))
+
+        if accessible_only:
+            all_repos = _get_all_repos()
+            query_lower = query.lower()
+            return to_repo_info(
+                r
+                for r in all_repos
+                if not r.get("archived") and query_lower in r["full_name"].lower()
+            )
+
+        assert not use_cache, "use_cache is not supported with the Search API path"
         full_query = build_repository_query(self.model.metadata, self.model.name, query)
-        response = self.get_client().search_repositories(full_query)
-        search_repos: list[RepositoryInfo] = [
-            {
-                "name": i["name"],
-                "identifier": i["full_name"],
-                "external_id": self.get_repo_external_id(i),
-                "default_branch": i.get("default_branch"),
-            }
-            for i in response.get("items", [])
-        ]
-        return search_repos
+        response = client.search_repositories(full_query)
+        return to_repo_info(response.get("items", []))
 
     def get_unmigratable_repositories(self) -> list[RpcRepository]:
         accessible_repos = self.get_repositories()

src/sentry/integrations/github_enterprise/integration.py

@@ -226,6 +226,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         if not query:
             all_repos = self.get_client().get_repos(page_number_limit=page_number_limit)

src/sentry/integrations/gitlab/integration.py

@@ -179,6 +179,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         try:
             # Note: gitlab projects are the same things as repos everywhere else

src/sentry/integrations/perforce/integration.py

@@ -361,6 +361,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         """
         Get list of depots/streams from Perforce server.

src/sentry/integrations/source_code_management/repository.py

@@ -59,6 +59,7 @@ def get_repositories(
         query: str | None = None,
         page_number_limit: int | None = None,
         accessible_only: bool = False,
+        use_cache: bool = False,
     ) -> list[RepositoryInfo]:
         """
         Get a list of available repositories for an installation