Bundle Analysis: Add mutation for toggling bundle caching configuration

Author: JerrySentry

core/commands/repository/interactors/update_bundle_config.py

@@ -0,0 +1,68 @@
+from typing import Dict, List
+
+from shared.django_apps.bundle_analysis.models import CacheConfig
+
+from codecov.commands.base import BaseInteractor
+from codecov.commands.exceptions import ValidationError
+from codecov.db import sync_to_async
+from codecov_auth.models import Owner
+from core.models import Repository
+
+
+class UploadBundleConfigInteractor(BaseInteractor):
+    def validate(
+        self, repo: Repository, cache_config: List[Dict[str, str | bool]]
+    ) -> None:
+        if not repo:
+            raise ValidationError("Repo not found")
+
+        # Find any missing bundle names
+        bundle_names = [
+            bundle["bundle_name"]
+            for bundle in cache_config
+            # the value of bundle_name is always a string, just do this check to appease mypy
+            if isinstance(bundle["bundle_name"], str)
+        ]
+        existing_bundle_names = set(
+            CacheConfig.objects.filter(
+                repo_id=repo.pk, bundle_name__in=bundle_names
+            ).values_list("bundle_name", flat=True)
+        )
+        missing_bundles = set(bundle_names) - existing_bundle_names
+        if missing_bundles:
+            raise ValidationError(
+                f"The following bundle names do not exist: {', '.join(missing_bundles)}"
+            )
+
+    @sync_to_async
+    def execute(
+        self,
+        owner_username: str,
+        repo_name: str,
+        cache_config: List[Dict[str, str | bool]],
+    ) -> List[Dict[str, str | bool]]:
+        author = Owner.objects.filter(
+            username=owner_username, service=self.service
+        ).first()
+        repo = (
+            Repository.objects.viewable_repos(self.current_owner)
+            .filter(author=author, name=repo_name)
+            .first()
+        )
+
+        self.validate(repo, cache_config)
+
+        results = []
+        for bundle in cache_config:
+            bundle_name = bundle["bundle_name"]
+            is_caching = bundle["toggle_caching"]
+            CacheConfig.objects.filter(repo_id=repo.pk, bundle_name=bundle_name).update(
+                is_caching=is_caching
+            )
+            results.append(
+                {
+                    "bundle_name": bundle_name,
+                    "is_cached": is_caching,
+                }
+            )
+        return results

core/commands/repository/repository.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import Awaitable, Optional
+from typing import Awaitable, Dict, List, Optional
 
 from codecov.commands.base import BaseCommand
 from codecov_auth.models import Owner, RepositoryToken
@@ -16,6 +16,7 @@
 from .interactors.regenerate_repository_upload_token import (
     RegenerateRepositoryUploadTokenInteractor,
 )
+from .interactors.update_bundle_config import UploadBundleConfigInteractor
 from .interactors.update_repository import UpdateRepositoryInteractor
 
 
@@ -85,3 +86,13 @@ def encode_secret_string(self, owner: Owner, repo_name: str, value: str) -> str:
         return self.get_interactor(EncodeSecretStringInteractor).execute(
             owner, repo_name, value
         )
+
+    def update_bundle_caching(
+        self,
+        owner_username: str,
+        repo_name: str,
+        cache_config: List[Dict[str, str | bool]],
+    ) -> Awaitable[List[Dict[str, str | bool]]]:
+        return self.get_interactor(UploadBundleConfigInteractor).execute(
+            owner_username, repo_name, cache_config
+        )

graphql_api/types/inputs/bundle_analysis_cache_config.graphql

@@ -0,0 +1,10 @@
+input BundleCachingInput {
+  bundleName: String!
+  toggleCaching: Boolean!
+}
+
+input UpdateBundleCachingInput {
+  owner: String!
+  repoName: String!
+  bundles: [BundleCachingInput!]!
+}

graphql_api/types/mutation/__init__.py

@@ -23,6 +23,7 @@
 from .start_trial import gql_start_trial
 from .store_event_metrics import gql_store_event_metrics
 from .sync_with_git_provider import gql_sync_with_git_provider
+from .update_bundle_caching import gql_update_bundle_caching
 from .update_default_organization import gql_update_default_organization
 from .update_profile import gql_update_profile
 from .update_repository import gql_update_repository
@@ -55,3 +56,4 @@
 mutation = mutation + gql_store_event_metrics
 mutation = mutation + gql_save_okta_config
 mutation = mutation + gql_set_upload_token_required
+mutation = mutation + gql_update_bundle_caching

graphql_api/types/mutation/mutation.graphql

@@ -39,4 +39,5 @@ type Mutation {
   storeEventMetric(input: StoreEventMetricsInput!): StoreEventMetricsPayload
   saveOktaConfig(input: SaveOktaConfigInput!): SaveOktaConfigPayload
   setUploadTokenRequired(input: SetUploadTokenRequiredInput!): SetUploadTokenRequiredPayload
+  updateBundleCaching(input: UpdateBundleCachingInput!): UpdateBundleCachingPayload
 }

graphql_api/types/mutation/mutation.py

@@ -49,6 +49,10 @@
     error_sync_with_git_provider,
     resolve_sync_with_git_provider,
 )
+from .update_bundle_caching import (
+    error_update_bundle_caching,
+    resolve_update_bundle_caching,
+)
 from .update_default_organization import (
     error_update_default_organization,
     resolve_update_default_organization,
@@ -99,6 +103,7 @@
 
 mutation_bindable.field("saveOktaConfig")(resolve_save_okta_config)
 mutation_bindable.field("setUploadTokenRequired")(resolve_set_upload_token_required)
+mutation_bindable.field("updateBundleCaching")(resolve_update_bundle_caching)
 
 mutation_resolvers = [
     mutation_bindable,
@@ -128,4 +133,5 @@
     error_store_event_metrics,
     error_save_okta_config,
     error_set_upload_token_required,
+    error_update_bundle_caching,
 ]

graphql_api/types/mutation/update_bundle_caching/__init__.py

@@ -0,0 +1,15 @@
+from graphql_api.helpers.ariadne import ariadne_load_local_graphql
+
+from .update_bundle_caching import (
+    error_update_bundle_caching,
+    resolve_update_bundle_caching,
+)
+
+gql_update_bundle_caching = ariadne_load_local_graphql(
+    __file__, "update_bundle_caching.graphql"
+)
+
+__all__ = [
+    "error_update_bundle_caching",
+    "resolve_update_bundle_caching",
+]

graphql_api/types/mutation/update_bundle_caching/update_bundle_caching.graphql

@@ -0,0 +1,11 @@
+union UpdateBundleCachingError = UnauthenticatedError | ValidationError
+
+type UpdateBundleCachingResult {
+  bundleName: String
+  isCached: Boolean
+}
+
+type UpdateBundleCachingPayload {
+  results: [UpdateBundleCachingResult!]
+  error: UpdateBundleCachingError
+}

graphql_api/types/mutation/update_bundle_caching/update_bundle_caching.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from ariadne import UnionType
+from graphql import GraphQLResolveInfo
+
+from core.commands.repository.repository import RepositoryCommands
+from graphql_api.helpers.mutation import (
+    require_authenticated,
+    resolve_union_error_type,
+    wrap_error_handling_mutation,
+)
+
+
+@wrap_error_handling_mutation
+@require_authenticated
+async def resolve_update_bundle_caching(
+    _: Any, info: GraphQLResolveInfo, input: Dict[str, Any]
+) -> Dict[str, List[Dict[str, str | bool]]]:
+    command: RepositoryCommands = info.context["executor"].get_command("repository")
+
+    results = await command.update_bundle_caching(
+        repo_name=input.get("repo_name", ""),
+        owner_username=input.get("owner", ""),
+        cache_config=input.get("bundles", []),
+    )
+    return {"results": results}
+
+
+error_update_bundle_caching = UnionType("UpdateBundleCachingError")
+error_update_bundle_caching.type_resolver(resolve_union_error_type)