resolvers/author.py

@@ -314,16 +314,22 @@ async def load_authors_search(_, info, text: str, limit: int = 10, offset: int =
         list: List of authors matching the search criteria
     """
     
+    logger.info(f"Executing load_authors_search for text: '{text}', limit: {limit}, offset: {offset}")
+
     # Get author IDs from search engine (already sorted by relevance)
     search_results = await search_service.search_authors(text, limit, offset)
 
     if not search_results:
+        logger.info(f"No authors found in search for '{text}'")
         return []
 
     author_ids = [result.get("id") for result in search_results if result.get("id")]
     if not author_ids:
+        logger.warning(f"Search for '{text}' returned results but no valid IDs.")
         return []
 
+    logger.info(f"Search returned {len(author_ids)} author IDs: {author_ids}")
+
     # Fetch full author objects from DB
     with local_session() as session:
         # Simple query to get authors by IDs - no need for stats here
@@ -331,6 +337,7 @@ async def load_authors_search(_, info, text: str, limit: int = 10, offset: int =
         db_authors = session.execute(authors_query).scalars().all()
     
     if not db_authors:
+        logger.warning(f"No authors found in DB for IDs: {author_ids}")
         return []
 
     # Create a dictionary for quick lookup
@@ -339,6 +346,7 @@ async def load_authors_search(_, info, text: str, limit: int = 10, offset: int =
     # Keep the order from search results (maintains the relevance sorting)
     ordered_authors = [authors_dict[author_id] for author_id in author_ids if author_id in authors_dict]
 
+    logger.info(f"Returning {len(ordered_authors)} authors matching search order.")
     return ordered_authors
 
 

services/search.py

@@ -748,44 +748,28 @@ class SearchService:
 
         cache_key = f"author:{text}"
 
-        # Check if we can serve from cache
+        # Try cache first if enabled
         if SEARCH_CACHE_ENABLED:
-            has_cache = await self.cache.has_query(cache_key)
-            if has_cache:
-                cached_results = await self.cache.get(cache_key, limit, offset)
-                if cached_results is not None:
-                    return cached_results
+            if await self.cache.has_query(cache_key):
+                return await self.cache.get(cache_key, limit, offset)
 
-        # Not in cache or cache disabled, perform new search
         try:
-            search_limit = limit
-
-            if SEARCH_CACHE_ENABLED:
-                search_limit = SEARCH_PREFETCH_SIZE
-            else:
-                search_limit = limit
-
             logger.info(
-                f"Searching authors for: '{text}' (limit={limit}, offset={offset}, search_limit={search_limit})"
+                f"Searching authors for: '{text}' (limit={limit}, offset={offset})"
             )
             response = await self.client.post(
-                "/search-author", json={"text": text, "limit": search_limit}
+                "/search-author", json={"text": text, "limit": limit + offset}
             )
             response.raise_for_status()
 
             result = response.json()
             author_results = result.get("results", [])
 
-            # Filter out any invalid results if necessary
-            valid_results = [r for r in author_results if r.get("id", "").isdigit()]
-            if len(valid_results) != len(author_results):
-                author_results = valid_results
-
+            # Store in cache if enabled
             if SEARCH_CACHE_ENABLED:
-                # Store the full prefetch batch, then page it
                 await self.cache.store(cache_key, author_results)
-                return await self.cache.get(cache_key, limit, offset)
-                
+
+            # Apply offset/limit
             return author_results[offset : offset + limit]
 
         except Exception as e: