Fix: OpenSearch queries are huge (#7580)

Author: nadove-ucsc

src/azul/service/__init__.py

@@ -343,6 +343,25 @@ def to_json(self) -> JSON:
     def update(self, filters: FiltersJSON) -> Self:
         return attr.evolve(self, explicit={**self.explicit, **filters})
 
+    def reify_implicit_only(self, plugin: MetadataPlugin) -> FiltersJSON:
+        """
+        Construct filters for *only* the implicit restriction on accessible
+        sources. This is conceptually equivalent to the set difference
+        `self.reify(limit_access=True) - self.reify(limit_access=False)`.
+
+        :param plugin: Metadata plugin for the current request's catalog
+        """
+        source_id_field = plugin.special_fields.source_id.name
+        filters = copy_json(self.explicit)
+        explicit_sources = self._extract_filter(filters, source_id_field, default=None)
+        if explicit_sources is not None:
+            self._forbid_explicit_inaccessible_sources(explicit_sources)
+        return {
+            source_id_field: {
+                'is': sorted(self.source_ids),
+            }
+        }
+
     def reify(self,
               plugin: MetadataPlugin,
               *,

src/azul/service/elasticsearch_service.py

@@ -181,6 +181,9 @@ class FilterStage(_ElasticsearchStage[Response, Response]):
     def prepare_request(self, request: Search) -> Search:
         query = self.prepare_query(self.prepared_filters)
         if self.post_filter:
+            if self.service.always_limit_access or self._limit_access:
+                access_query = self.prepare_query(self.prepared_access_filter)
+                request = request.query(access_query)
             request = request.post_filter(query)
         else:
             request = request.query(query)
@@ -191,10 +194,17 @@ def process_response(self, response: Response) -> Response:
 
     @cached_property
     def prepared_filters(self) -> TranslatedFilters:
-        limit_access = self.service.always_limit_access or self._limit_access
+        # The implicit source filter is always applied via a query, and would
+        # therefore be redundant in the post_filter
+        limit_access = (self.service.always_limit_access or self._limit_access) and not self.post_filter
         filters_json = self.filters.reify(self.plugin, limit_access=limit_access)
         return self._translate_filters(filters_json)
 
+    @cached_property
+    def prepared_access_filter(self) -> TranslatedFilters:
+        filters_json = self.filters.reify_implicit_only(self.plugin)
+        return self._translate_filters(filters_json)
+
     @property
     @abstractmethod
     def _limit_access(self) -> bool: