fix: refactor user-repos and archived endpoints to use service methods

- Changed list_user_repositories to call service.list_user_repos() instead of direct store access
- Changed list_archived_repositories to call service.list_archived_repos() instead of direct store access
- Removes duplicate executor wrapping (already handled in service layer)
- Ensures proper session management through service methods
- Should fix hanging issues on these endpoints

Author: alimkhann

commitly-backend/app/api/github.py

@@ -58,15 +58,15 @@ async def github_status(
     session: Session = Depends(get_db),
 ):
     import asyncio
-    
+
     # Wrap sync DB call in executor to avoid blocking event loop
     def get_status():
         store = GitHubTokenStore(session)
         return store.get_token(current_user["sub"])
-    
+
     loop = asyncio.get_event_loop()
     record = await loop.run_in_executor(None, get_status)
-    
+
     if record is None:
         return OAuthStatusResponse(connected=False)
     return OAuthStatusResponse(

commitly-backend/app/api/roadmap.py

@@ -214,16 +214,8 @@ async def list_user_repositories(
     current_user: ClerkClaims = Depends(require_clerk_auth),
     service: RoadmapService = Depends(get_roadmap_service),
 ) -> list[UserRepoStateResponse]:
-    import asyncio
-    
-    # Wrap sync DB call in executor to avoid blocking event loop
     user_id = get_user_id(current_user)
-    
-    def get_repos():
-        return service._pin_store.list_states(user_id)
-    
-    loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, get_repos)
+    return await service.list_user_repos(user_id)
 
 
 @router.post("/sync/{owner}/{repo}", response_model=UserRepoStateResponse)
@@ -272,16 +264,8 @@ async def list_archived_repositories(
     current_user: ClerkClaims = Depends(require_clerk_auth),
     service: RoadmapService = Depends(get_roadmap_service),
 ) -> list[UserRepoStateResponse]:
-    import asyncio
-    
-    # Wrap sync DB call in executor to avoid blocking event loop
     user_id = get_user_id(current_user)
-    
-    def get_archived():
-        return service._pin_store.list_archived(user_id)
-    
-    loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, get_archived)
+    return await service.list_archived_repos(user_id)
 
 
 @router.post("/{owner}/{repo}/rating", response_model=RatingResponse)

commitly-backend/app/core/auth.py

@@ -222,7 +222,7 @@ async def verify_clerk_token_async(token: str) -> ClerkClaims:
     """Async version of verify_clerk_token that doesn't block the event loop."""
     import asyncio
     import logging
-    
+
     logger = logging.getLogger(__name__)
     logger.info("verify_clerk_token_async: Starting token verification")
 
@@ -237,7 +237,7 @@ async def verify_clerk_token_async(token: str) -> ClerkClaims:
     if not isinstance(kid, str):
         logger.error("verify_clerk_token_async: Missing key identifier")
         raise InvalidClerkToken("Missing key identifier")
-    
+
     logger.info(f"verify_clerk_token_async: Fetching JWKS for kid={kid}")
 
     # Use async version to avoid blocking
@@ -262,7 +262,7 @@ def verify_signature():
         if not public_key.verify(message.encode("utf-8"), decoded_signature):
             logger.error("verify_signature: Signature verification failed")
             raise InvalidClerkToken("Signature verification failed")
-        
+
         logger.info("verify_signature: Signature verified, getting claims")
         claims = jwt.get_unverified_claims(token)
         logger.info("verify_signature: Claims retrieved")

commitly-backend/app/services/roadmap_service.py

@@ -205,7 +205,7 @@ async def record_roadmap_view(
             user_id: User identifier (optional for anonymous users)
         """
         import asyncio
-        
+
         if not self._view_tracker:
             # View tracking disabled
             return
@@ -220,7 +220,7 @@ def record_view():
             if should_count:
                 # Increment the view count on the roadmap
                 self._result_store.increment_view_count(repo_full_name)
-        
+
         loop = asyncio.get_event_loop()
         await loop.run_in_executor(None, record_view)
 
@@ -238,52 +238,52 @@ async def sync_repo(
         self, owner: str, repo: str, user_id: str
     ) -> UserRepoStateResponse:
         import asyncio
-        
+
         full_name = f"{owner}/{repo}"
-        
+
         # Wrap DB operations in executor
         loop = asyncio.get_event_loop()
-        
+
         def get_roadmap():
             return self._result_store.get(full_name)
-        
+
         roadmap = await loop.run_in_executor(None, get_roadmap)
-        
+
         if roadmap is None:
             await self.generate(
                 repo_url=f"https://github.com/{full_name}",
                 force_refresh=False,
                 actor_id=user_id,
             )
             roadmap = await loop.run_in_executor(None, get_roadmap)
-            
+
         if roadmap is None:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
                 detail="Roadmap could not be generated for this repository.",
             )
-        
+
         def check_and_upsert():
             states = self._pin_store.list_states(user_id)
             was_synced = any(state.repo_full_name == full_name for state in states)
-            
+
             self._pin_store.upsert_state(
                 user_id,
                 full_name,
                 status="synced",
                 is_archived=False,
                 progress_percent=0,
             )
-            
+
             record_after = self._result_store.get(full_name)
             if not was_synced:
                 self._result_store.increment_sync_count(full_name)
                 record_after = self._result_store.get(full_name)
-                
+
             return was_synced, record_after
-        
+
         was_synced, record_after = await loop.run_in_executor(None, check_and_upsert)
-        
+
         return UserRepoStateResponse(
             repo_full_name=full_name,
             status="synced",
@@ -295,16 +295,16 @@ def check_and_upsert():
 
     async def desync_repo(self, owner: str, repo: str, user_id: str) -> None:
         import asyncio
-        
+
         full_name = f"{owner}/{repo}"
-        
+
         def desync():
             states = self._pin_store.list_states(user_id)
             had_state = any(state.repo_full_name == full_name for state in states)
             self._pin_store.unpin(user_id, full_name)
             if had_state:
                 self._result_store.decrement_sync_count(full_name)
-        
+
         loop = asyncio.get_event_loop()
         await loop.run_in_executor(None, desync)
 
@@ -318,9 +318,9 @@ async def archive_repo(
     ) -> UserRepoStateResponse:
         """Archive a repository for a user."""
         import asyncio
-        
+
         full_name = f"{owner}/{repo}"
-        
+
         def archive():
             states = self._pin_store.list_states(user_id)
             existing_state = next(
@@ -343,7 +343,7 @@ def archive():
                     detail="Failed to archive repository.",
                 )
             return updated_state
-        
+
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, archive)
 
@@ -352,9 +352,9 @@ async def unarchive_repo(
     ) -> UserRepoStateResponse:
         """Unarchive a repository for a user."""
         import asyncio
-        
+
         full_name = f"{owner}/{repo}"
-        
+
         def unarchive():
             archived = self._pin_store.list_archived(user_id)
             existing_archived = next(
@@ -377,7 +377,7 @@ def unarchive():
                     detail="Failed to unarchive repository.",
                 )
             return updated_state
-        
+
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, unarchive)
 
@@ -392,14 +392,14 @@ async def set_rating(
     ) -> RatingResponse:
         """Set or update a user's rating for a repository."""
         import asyncio
-        
+
         if not self._rating_store:
             raise HTTPException(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
                 detail="Rating service is not available",
             )
         full_name = f"{owner}/{repo}"
-        
+
         def upsert():
             record = self._rating_store.upsert_rating(user_id, full_name, rating)
             return RatingResponse(
@@ -409,7 +409,7 @@ def upsert():
                 created_at=record.created_at,
                 updated_at=record.updated_at,
             )
-        
+
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, upsert)
 
@@ -418,11 +418,11 @@ async def get_user_rating(
     ) -> RatingResponse | None:
         """Get a user's rating for a repository."""
         import asyncio
-        
+
         if not self._rating_store:
             return None
         full_name = f"{owner}/{repo}"
-        
+
         def get_rating():
             record = self._rating_store.get_user_rating(user_id, full_name)
             if not record:
@@ -434,7 +434,7 @@ def get_rating():
                 created_at=record.created_at,
                 updated_at=record.updated_at,
             )
-        
+
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, get_rating)
         return RatingResponse(