Remove :class_name option in favor of :scope

No soft deprecation here, since federated search has not been published
yet.

Author: ellnix

README.md

@@ -328,8 +328,8 @@ Federated search is similar to multi search, except that results are not grouped
 ```ruby
 results = Meilisearch::Rails.federated_search(
   queries: [
-    { q: 'Harry', class_name: 'Book' },
-    { q: 'Attack on Titan', class_name: 'Manga' }
+    { q: 'Harry', scope: Book.all },
+    { q: 'Attack on Titan', scope: Manga.all }
   ]
 )
 ```
@@ -367,30 +367,31 @@ results = Meilisearch::Rails.federated_search(
 ```ruby
 results = Meilisearch::Rails.federated_search(
   queries: {
-    'books_production' => { q: 'Harry', class_name: 'Book' },
-    'mangas_production' => { q: 'Attack on Titan', class_name: 'Manga' }
+    'books_production' => { q: 'Harry', scope: Book.all },
+    'mangas_production' => { q: 'Attack on Titan', scope: Manga.all }
   }
 )
 ```
 
 ```ruby
 results = Meilisearch::Rails.federated_search(
   queries: {
-    'potter' => { q: 'Harry', class_name: 'Book', index_uid: 'books_production' },
-    'titan' => { q: 'Attack on Titan', class_name: 'Manga', index_uid: 'mangas_production' }
+    'potter' => { q: 'Harry', scope: Book.all, index_uid: 'books_production' },
+    'titan' => { q: 'Attack on Titan', scope: Manga.all, index_uid: 'mangas_production' }
   }
 )
 ```
 
 ### Loading records <!-- omit in toc -->
 
-Records are loaded when the `:class_name` option is passed, or when a hash query is used with models as keys:
+Records are loaded when the `:scope` option is passed (may be a model or a relation), 
+or when a hash query is used with models as keys:
 
 ```ruby
 results = Meilisearch::Rails.federated_search(
   queries: [
-    { q: 'Harry', class_name: 'Book' },
-    { q: 'Attack on Titan', class_name: 'Manga' },
+    { q: 'Harry', scope: Book },
+    { q: 'Attack on Titan', scope: Manga },
   ]
 )
 ```
@@ -406,6 +407,19 @@ results = Meilisearch::Rails.federated_search(
 
 If the model is not provided, hashes are returned!
 
+### Scoping records <!-- omit in toc -->
+
+Any relation passed as `:scope` is used as the starting point when loading records:
+
+```ruby
+results = Meilisearch::Rails.federated_search(
+  queries: [
+    { q: 'Harry', scope: Book.where('year <= 2006') },
+    { q: 'Attack on Titan', scope: Manga.where(author: Author.find_by(name: 'Iseyama')) },
+  ]
+)
+```
+
 ### Specifying the search index <!-- omit in toc -->
 
 In order of precedence, to figure out which index to search, Meilisearch Rails will check:
@@ -415,7 +429,7 @@ In order of precedence, to figure out which index to search, Meilisearch Rails w
    results = Meilisearch::Rails.federated_search(
      queries: [
        # Searching the 'fantasy_books' index
-       { q: 'Harry', class_name: 'Book', index_uid: 'fantasy_books' },
+       { q: 'Harry', scope: Book, index_uid: 'fantasy_books' },
      ]
    )
    ```
@@ -425,7 +439,7 @@ In order of precedence, to figure out which index to search, Meilisearch Rails w
      queries: [
        # Searching the index associated with the Book model
        # i. e. Book.index.uid
-       { q: 'Harry', class_name: 'Book' },
+       { q: 'Harry', scope: Book },
      ]
    )
    ```
@@ -434,7 +448,7 @@ In order of precedence, to figure out which index to search, Meilisearch Rails w
    results = Meilisearch::Rails.federated_search(
      queries: {
        # Searching index 'books_production'
-       books_production: { q: 'Harry', class_name: 'Book' },
+       books_production: { q: 'Harry', scope: Book },
      }
    )
    ```
@@ -446,8 +460,8 @@ In addition to queries, federated search also accepts `:federation` parameters w
 ```ruby
 results = Meilisearch::Rails.federated_search(
   queries: [
-    { q: 'Harry', class_name: 'Book' },
-    { q: 'Attack on Titan', class_name: 'Manga' },
+    { q: 'Harry', scope: Book },
+    { q: 'Attack on Titan', scope: Manga },
   ],
   federation: { offset: 10, limit: 5 }
 )

lib/meilisearch/rails/multi_search.rb

@@ -27,7 +27,8 @@ def federated_search(queries:, federation: {})
         queries.map! { |item| [nil, item] } if queries.is_a?(Array)
 
         cleaned_queries = queries.filter_map do |(index_target, options)|
-          index_target = options.delete(:index_uid) || index_target || options[:class_name]&.constantize
+          model_class = options[:scope].respond_to?(:model) ? options[:scope].model : options[:scope]
+          index_target = options.delete(:index_uid) || index_target || model_class
 
           strip_pagination_options(options)
           normalize(options, index_target)
@@ -46,7 +47,7 @@ def normalize(options, index_target)
         return nil if index_target.nil?
 
         options
-          .except(:class_name)
+          .except(:scope, :class_name)
           .merge!(index_uid: index_target)
       end
 

lib/meilisearch/rails/multi_search/federated_search_result.rb

@@ -23,14 +23,14 @@ def load_hits(hits, searches)
         keys_and_records_by_pos = hits_by_pos.to_h do |pos, group_hits|
           search_target, search_opts = searches[pos]
 
-          klass = if search_opts[:class_name]
-                    search_opts[:class_name].constantize
+          scope = if search_opts[:scope]
+                    search_opts[:scope]
                   elsif search_target.instance_of?(Class)
                     search_target
                   end
 
-          if klass.present?
-            [pos, load_results(klass, group_hits)]
+          if scope.present?
+            [pos, load_results(scope, group_hits)]
           else
             [pos, [nil, group_hits]]
           end
@@ -49,15 +49,17 @@ def load_hits(hits, searches)
         end
       end
 
-      def load_results(klass, hits)
+      def load_results(scope, hits)
+        klass = scope.respond_to?(:model) ? scope.model : scope
+
         pk_method = klass.ms_primary_key_method
         pk_method = pk_method.in if Utilities.mongo_model?(klass)
 
         condition_key = pk_is_virtual?(klass, pk_method) ? klass.primary_key : pk_method
 
         hits_by_id = hits.index_by { |hit| hit[condition_key.to_s] }
 
-        records = klass.where(condition_key => hits_by_id.keys)
+        records = scope.where(condition_key => hits_by_id.keys)
 
         results_by_id = records.index_by do |record|
           record.send(condition_key).to_s

spec/federated_search_spec.rb

@@ -46,8 +46,8 @@
     it 'ranks better match above worse match' do
       results = Meilisearch::Rails.federated_search(
         queries: [
-          { q: 'Steve', class_name: 'Book' },
-          { q: 'black', class_name: 'Color' }
+          { q: 'Steve', scope: Book.all },
+          { q: 'black', scope: Color.all }
         ]
       )
 
@@ -57,11 +57,11 @@
 
     context 'when :index_uid is passed' do
       it 'takes precedence over other sources of index uids' do
-        Meilisearch::Rails.client.create_index('temp_books').await
+        Meilisearch::Rails.client.create_index('temp_books')
         Meilisearch::Rails.client.swap_indexes(['temp_books', Book.index.uid]).await
 
         results = Meilisearch::Rails.federated_search(
-          queries: [{ q: 'Moby', class_name: 'Book', index_uid: 'temp_books' }]
+          queries: [{ q: 'Moby', scope: Book.all, index_uid: 'temp_books' }]
         )
 
         expect(results).to contain_exactly(books['Moby Dick'])
@@ -70,23 +70,41 @@
       end
     end
 
-    context 'when :class_name is passed' do
-      it 'returns ORM records with inferred index names' do
-        results = Meilisearch::Rails.federated_search(
-          queries: [
-            { q: 'Steve', class_name: 'Book' },
-            { q: 'palm', class_name: 'Product' },
-            { q: 'bl', class_name: 'Color' }
-          ]
-        )
+    context 'when :scope is passed' do
+      context 'when :scope is a model' do
+        it 'returns ORM records with inferred index names' do
+          results = Meilisearch::Rails.federated_search(
+            queries: [
+              { q: 'Steve', scope: Book },
+              { q: 'palm', scope: Product },
+              { q: 'bl', scope: Color }
+            ]
+          )
 
-        expect(results).to contain_exactly(
-          books['Steve Jobs'], products['palmpre'], products['palm pixi plus'], colors['blue'], colors['black']
-        )
+          expect(results).to contain_exactly(
+            books['Steve Jobs'], products['palmpre'], products['palm pixi plus'], colors['blue'], colors['black']
+          )
+        end
+      end
+
+      context 'when :scope is a Relation' do
+        it 'returns results within scope' do
+          results = Meilisearch::Rails.federated_search(
+            queries: [
+              { q: 'Steve', scope: Book },
+              { q: 'palm', scope: Product.where(name: 'palmpre') },
+              { q: 'bl', scope: Color }
+            ]
+          )
+
+          expect(results).to contain_exactly(
+            books['Steve Jobs'], products['palmpre'], colors['blue'], colors['black']
+          )
+        end
       end
     end
 
-    context 'without :class_name' do
+    context 'without :scope' do
       it 'returns raw hashes' do
         results = Meilisearch::Rails.federated_search(
           queries: [{ q: 'Steve', index_uid: Book.index.uid }]
@@ -99,13 +117,13 @@
 
   context 'with queries passed as a hash' do
     context 'when the keys are index names' do
-      it 'loads the right models with :class_name' do
+      it 'loads the right models with :scope' do
         Meilisearch::Rails.client.create_index('temp_books').await
         Meilisearch::Rails.client.swap_indexes(['temp_books', Book.index.uid]).await
 
         results = Meilisearch::Rails.federated_search(
           queries: {
-            'temp_books' => { q: 'Steve', class_name: 'Book' }
+            'temp_books' => { q: 'Steve', scope: Book }
           }
         )
 
@@ -114,7 +132,7 @@
         Meilisearch::Rails.client.delete_index('temp_books')
       end
 
-      it 'returns hashes without :class_name' do
+      it 'returns hashes without :scope' do
         results = Meilisearch::Rails.federated_search(
           queries: {
             Book.index.uid => { q: 'Steve' }
@@ -159,7 +177,7 @@
 
         results = Meilisearch::Rails.federated_search(
           queries: {
-            classics: { q: 'Moby', class_name: 'Book', index_uid: 'temp_books' }
+            classics: { q: 'Moby', scope: Book, index_uid: 'temp_books' }
           }
         )
 
@@ -171,7 +189,7 @@
       it 'requires :index_uid to search the correct index' do
         expect do
           Meilisearch::Rails.federated_search(
-            queries: { all_books: { q: 'Moby', class_name: 'Book' } }
+            queries: { all_books: { q: 'Moby', scope: Book } }
           )
         end.to raise_error(Meilisearch::ApiError).with_message(/Index `all_books` not found/)
       end
@@ -185,13 +203,13 @@
       allow(Meilisearch::Rails).to receive(:logger).and_return(logger)
     end
 
-    it 'warns if query has pagination options' do
+    it 'warns if query has pagination options, but completes the search anyway' do
       results = Meilisearch::Rails.federated_search(
         queries: [
-          { q: 'Steve', class_name: 'Book', limit: 1 },
-          { q: 'No results please', class_name: 'Book', offset: 1 },
-          { q: 'No results please', class_name: 'Book', hits_per_page: 1 },
-          { q: 'No results please', class_name: 'Book', page: 1 }
+          { q: 'Steve', scope: Book, limit: 1 },
+          { q: 'No results please', scope: Book, offset: 1 },
+          { q: 'No results please', scope: Book, hits_per_page: 1 },
+          { q: 'No results please', scope: Book, page: 1 }
         ]
       )
 
@@ -203,19 +221,19 @@
       expect(results).to contain_exactly(books['Steve Jobs'])
     end
 
-    it 'warns if :class_name argument is not a meilisearch model' do
+    it 'warns if :scope model is not a meilisearch model' do
       results = Meilisearch::Rails.federated_search(
-        queries: [{ q: 'Steve', class_name: 'String' }]
+        queries: [{ q: 'Steve', scope: String }]
       )
 
       expect(logger).to have_received('warn').with(a_string_including('does not have an #index'))
       expect(results).to be_empty
     end
 
-    it 'warns if :federation argument is nil' do
+    it 'warns if :federation argument is nil, but completes search anyway' do
       # This would disable federated search if not caught
       results = Meilisearch::Rails.federated_search(
-        queries: [{ q: 'Steve', class_name: 'Book' }],
+        queries: [{ q: 'Steve', scope: Book }],
         federation: nil
       )