meilisearch-rails 0.10.2 → 0.16.0

data/lib/meilisearch/rails/configuration.rb

@@ -1,4 +1,4 @@
-module MeiliSearch
+module Meilisearch
   module Rails
     module Configuration
       def configuration
@@ -44,11 +44,11 @@ module MeiliSearch
       def client
         return black_hole unless active?
 
-        ::MeiliSearch::Client.new(
+        ::Meilisearch::Client.new(
           configuration[:meilisearch_url] || 'http://localhost:7700',
           configuration[:meilisearch_api_key],
           configuration.slice(:timeout, :max_retries)
-                       .merge(client_agents: MeiliSearch::Rails.qualified_version)
+                       .merge(client_agents: Meilisearch::Rails.qualified_version)
         )
       end
     end

data/lib/meilisearch/rails/errors.rb

@@ -1,4 +1,4 @@
-module MeiliSearch
+module Meilisearch
   module Rails
     class NoBlockGiven < StandardError; end
 
@@ -6,7 +6,7 @@ module MeiliSearch
 
     class NotConfigured < StandardError
       def message
-        'Please configure Meilisearch. Set MeiliSearch::Rails.configuration = ' \
+        'Please configure Meilisearch. Set Meilisearch::Rails.configuration = ' \
           "{meilisearch_url: 'YOUR_MEILISEARCH_URL', meilisearch_api_key: 'YOUR_API_KEY'}"
       end
     end

data/lib/meilisearch/rails/ms_clean_up_job.rb

@@ -0,0 +1,19 @@
+module Meilisearch
+  module Rails
+    class MSCleanUpJob < ::ActiveJob::Base
+      queue_as :meilisearch
+
+      def perform(documents)
+        documents.each do |document|
+          index = Meilisearch::Rails.client.index(document[:index_uid])
+
+          if document[:synchronous]
+            index.delete_document(document[:primary_key]).await
+          else
+            index.delete_document(document[:primary_key])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meilisearch/rails/ms_job.rb

@@ -1,4 +1,4 @@
-module MeiliSearch
+module Meilisearch
   module Rails
     class MSJob < ::ActiveJob::Base
       queue_as :meilisearch

data/lib/meilisearch/rails/multi_search/federated_search_result.rb

@@ -0,0 +1,78 @@
+require 'active_support/core_ext/module/delegation'
+
+module Meilisearch
+  module Rails
+    class FederatedSearchResult
+      attr_reader :metadata, :hits
+
+      def initialize(searches, raw_results)
+        hits = raw_results.delete('hits')
+        @hits = load_hits(hits, searches.to_a)
+        @metadata = raw_results
+      end
+
+      include Enumerable
+
+      delegate :each, :to_a, :to_ary, :empty?, :[], :first, :last, to: :@hits
+
+      private
+
+      def load_hits(hits, searches)
+        hits_by_pos = hits.group_by { |hit| hit['_federation']['queriesPosition'] }
+
+        keys_and_records_by_pos = hits_by_pos.to_h do |pos, group_hits|
+          search_target, search_opts = searches[pos]
+
+          scope = if search_opts[:scope]
+                    search_opts[:scope]
+                  elsif search_target.instance_of?(Class)
+                    search_target
+                  end
+
+          if scope.present?
+            [pos, load_results(scope, group_hits)]
+          else
+            [pos, [nil, group_hits]]
+          end
+        end
+
+        hits.filter_map do |hit|
+          hit_cond_key, recs_by_id = keys_and_records_by_pos[hit['_federation']['queriesPosition']]
+
+          if hit_cond_key.present?
+            record = recs_by_id[hit[hit_cond_key.to_s].to_s]
+            record&.formatted = hit['_formatted']
+            record
+          else
+            hit
+          end
+        end
+      end
+
+      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 = scope.where(condition_key => hits_by_id.keys)
+
+        results_by_id = records.index_by do |record|
+          record.send(condition_key).to_s
+        end
+
+        [condition_key, results_by_id]
+      end
+
+      def pk_is_virtual?(model_class, pk_method)
+        model_class.columns
+                   .map(&(Utilities.sequel_model?(model_class) ? :to_s : :name))
+                   .exclude?(pk_method.to_s)
+      end
+    end
+  end
+end

data/lib/meilisearch/rails/multi_search/multi_search_result.rb

@@ -0,0 +1,115 @@
+module Meilisearch
+  module Rails
+    class MultiSearchResult
+      attr_reader :metadata
+
+      def initialize(searches, raw_results)
+        @results = {}
+        @metadata = {}
+
+        searches.zip(raw_results['results']).each do |(target, search_options), result|
+          results_class = if search_options[:class_name]
+                            Meilisearch::Rails.logger.warn(
+                              '[meilisearch-rails] The :class_name option in multi search is deprecated, please use :scope instead.'
+                            )
+
+                            search_options[:class_name].constantize
+                          elsif target.instance_of?(Class)
+                            target
+                          elsif search_options[:scope]
+                            search_options[:scope]
+                          end
+
+          @results[target] = results_class ? load_results(results_class, result, scope: search_options[:scope]) : result['hits']
+
+          @metadata[target] = result.except('hits')
+        end
+      end
+
+      include Enumerable
+
+      def each_hit(&block)
+        Meilisearch::Rails.logger.warn(
+          <<~DEPRECATION
+            [meilisearch-rails] Flattening multi search results is deprecated.
+            If you do not want the results to be grouped, please use federated search instead.
+          DEPRECATION
+        )
+
+        @results.each_value do |results|
+          results.each(&block)
+        end
+      end
+
+      def each(&block)
+        Meilisearch::Rails.logger.info(
+          <<~INFO
+            [meilisearch-rails] #each on a multi search now iterates through grouped results.
+            If you do not want the results to be grouped, please use federated search instead.
+            To quickly go back to the old deprecated behavior, use `#each_hit`.
+          INFO
+        )
+
+        @results.each(&block)
+      end
+
+      def each_result(&block)
+        @results.each(&block)
+      end
+
+      def to_a
+        Meilisearch::Rails.logger.warn(
+          <<~DEPRECATION
+            [meilisearch-rails] Flattening multi search results is deprecated.
+            If you do not want the results to be grouped, please use federated search instead.
+          DEPRECATION
+        )
+        @results.values.flatten(1)
+      end
+      alias to_ary to_a
+
+      def to_h
+        @results
+      end
+      alias to_hash to_h
+
+      private
+
+      def load_results(klass, result, scope:)
+        scope ||= klass
+
+        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 =
+          result['hits'].index_by { |hit| hit[condition_key.to_s] }
+
+        records = scope.where(condition_key => hits_by_id.keys)
+
+        if records.respond_to? :in_order_of
+          records.in_order_of(condition_key, hits_by_id.keys).each do |record|
+            record.formatted = hits_by_id[record.send(condition_key).to_s]['_formatted']
+          end
+        else
+          results_by_id = records.index_by do |hit|
+            hit.send(condition_key).to_s
+          end
+
+          result['hits'].filter_map do |hit|
+            record = results_by_id[hit[condition_key.to_s].to_s]
+            record&.formatted = hit['_formatted']
+            record
+          end
+        end
+      end
+
+      def pk_is_virtual?(model_class, pk_method)
+        model_class.columns
+                   .map(&(Utilities.sequel_model?(model_class) ? :to_s : :name))
+                   .exclude?(pk_method.to_s)
+      end
+    end
+  end
+end

data/lib/meilisearch/rails/multi_search.rb

@@ -0,0 +1,104 @@
+require_relative 'multi_search/multi_search_result'
+require_relative 'multi_search/federated_search_result'
+
+module Meilisearch
+  module Rails
+    class << self
+      def multi_search(searches)
+        search_parameters = searches.map do |(index_target, options)|
+          model_class = options[:scope].respond_to?(:model) ? options[:scope].model : options[:scope]
+          index_target = options.delete(:index_uid) || model_class || index_target
+
+          paginate(options) if pagination_enabled?
+          normalize(options, index_target)
+        end
+
+        MultiSearchResult.new(searches, client.multi_search(queries: search_parameters))
+      end
+
+      def federated_search(queries:, federation: {})
+        if federation.nil?
+          Meilisearch::Rails.logger.warn(
+            '[meilisearch-rails] In federated_search, `nil` is an invalid `:federation` option. To explicitly use defaults, pass `{}`.'
+          )
+
+          federation = {}
+        end
+
+        queries.map! { |item| [nil, item] } if queries.is_a?(Array)
+
+        cleaned_queries = queries.filter_map do |(index_target, options)|
+          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)
+        end
+
+        raw_results = client.multi_search(queries: cleaned_queries, federation: federation)
+
+        FederatedSearchResult.new(queries, raw_results)
+      end
+
+      private
+
+      def normalize(options, index_target)
+        index_target = index_uid_from_target(index_target)
+
+        return nil if index_target.nil?
+
+        options
+          .except(:class_name, :scope)
+          .merge!(index_uid: index_target)
+      end
+
+      def index_uid_from_target(index_target)
+        case index_target
+        when String, Symbol
+          index_target
+        when Class
+          if index_target.respond_to?(:index)
+            index_target.index.uid
+          else
+            Meilisearch::Rails.logger.warn <<~MODEL_NOT_INDEXED
+              [meilisearch-rails] This class was passed to a multi/federated search but it does not have an #index: #{index_target}
+              [meilisearch-rails] Are you sure it has a `meilisearch` block?
+            MODEL_NOT_INDEXED
+
+            nil
+          end
+        end
+      end
+
+      def paginate(options)
+        %w[page hitsPerPage hits_per_page].each do |key|
+          # Deletes hitsPerPage to avoid passing along a meilisearch-ruby warning/exception
+          value = options.delete(key) || options.delete(key.to_sym)
+          options[key.underscore.to_sym] = value.to_i if value
+        end
+
+        # It is required to activate the finite pagination in Meilisearch v0.30 (or newer),
+        # to have at least `hits_per_page` defined or `page` in the search request.
+        options[:page] ||= 1
+      end
+
+      def strip_pagination_options(options)
+        pagination_options = %w[page hitsPerPage hits_per_page limit offset].select do |key|
+          options.delete(key) || options.delete(key.to_sym)
+        end
+
+        return if pagination_options.empty?
+
+        Meilisearch::Rails.logger.warn <<~WRONG_PAGINATION
+          [meilisearch-rails] Pagination options in federated search must apply to whole federation.
+          [meilisearch-rails] These options have been removed: #{pagination_options.join(', ')}.
+          [meilisearch-rails] Please pass them after queries, in the `federation:` option.
+        WRONG_PAGINATION
+      end
+
+      def pagination_enabled?
+        Meilisearch::Rails.configuration[:pagination_backend]
+      end
+    end
+  end
+end

data/lib/meilisearch/rails/null_object.rb

@@ -1,6 +1,6 @@
 require 'singleton'
 
-module MeiliSearch
+module Meilisearch
   module Rails
     class NullObject
       include Singleton

data/lib/meilisearch/rails/pagination/kaminari.rb

@@ -1,11 +1,11 @@
 unless defined? Kaminari
-  raise(MeiliSearch::BadConfiguration,
+  raise(Meilisearch::BadConfiguration,
         "Meilisearch: Please add 'kaminari' to your Gemfile to use kaminari pagination backend")
 end
 
 require 'kaminari/models/array_extension'
 
-module MeiliSearch
+module Meilisearch
   module Rails
     module Pagination
       class Kaminari < ::Kaminari::PaginatableArray
@@ -18,14 +18,20 @@ module MeiliSearch
         end
 
         def self.create(results, total_hits, options = {})
-          offset = ((options[:page] - 1) * options[:per_page])
+          unless Meilisearch::Rails.active?
+            total_hits = 0
+            options[:page] = 1
+            options[:per_page] = 1
+          end
+
+          offset = (options[:page] - 1) * options[:per_page]
           array = new results, limit: options[:per_page], offset: offset, total_count: total_hits
 
           if array.empty? && !results.empty?
             # since Kaminari 0.16.0, you need to pad the results with nil values so it matches the offset param
             # otherwise you'll get an empty array: https://github.com/amatsuda/kaminari/commit/29fdcfa8865f2021f710adaedb41b7a7b081e34d
             results = Array.new(offset) + results
-            array = new results, offset: offset, limit: options[:per_page], total_count: total_hits
+            array = new results, offset: offset, limit: limit, total_count: total_hits
           end
 
           array

data/lib/meilisearch/rails/pagination/will_paginate.rb

@@ -1,15 +1,21 @@
 begin
   require 'will_paginate/collection'
 rescue LoadError
-  raise(MeiliSearch::BadConfiguration,
-        "MeiliSearch: Please add 'will_paginate' to your Gemfile to use will_paginate pagination backend")
+  raise(Meilisearch::BadConfiguration,
+        "Meilisearch: Please add 'will_paginate' to your Gemfile to use will_paginate pagination backend")
 end
 
-module MeiliSearch
+module Meilisearch
   module Rails
     module Pagination
       class WillPaginate
         def self.create(results, total_hits, options = {})
+          unless Meilisearch::Rails.active?
+            total_hits = 0
+            options[:page] = 1
+            options[:per_page] = 1
+          end
+
           ::WillPaginate::Collection.create(options[:page], options[:per_page], total_hits) do |pager|
             pager.replace results
           end

data/lib/meilisearch/rails/pagination.rb

@@ -1,11 +1,11 @@
-module MeiliSearch
+module Meilisearch
   module Rails
     module Pagination
       autoload :WillPaginate, 'meilisearch/rails/pagination/will_paginate'
       autoload :Kaminari, 'meilisearch/rails/pagination/kaminari'
 
       def self.create(results, total_hits, options = {})
-        pagination_backend = MeiliSearch::Rails.configuration[:pagination_backend]
+        pagination_backend = Meilisearch::Rails.configuration[:pagination_backend]
 
         if pagination_backend.nil? || (is_pagy = pagination_backend.to_s == 'pagy')
           log_pagy_error if is_pagy
@@ -17,12 +17,12 @@ module MeiliSearch
       end
 
       def self.log_pagy_error
-        MeiliSearch::Rails.logger
-          .warning('[meilisearch-rails] Remove `pagination_backend: :pagy` from your initializer, `pagy` it is not required for `pagy`')
+        Meilisearch::Rails.logger
+          .warn('[meilisearch-rails] Remove `pagination_backend: :pagy` from your initializer, `pagy` it is not required for `pagy`')
       end
 
       def self.load_pagination!(pagination_backend, results, total_hits, options)
-        ::MeiliSearch::Rails::Pagination
+        ::Meilisearch::Rails::Pagination
           .const_get(pagination_backend.to_s.classify)
           .create(results, total_hits, options)
       rescue NameError

data/lib/meilisearch/rails/railtie.rb

@@ -1,6 +1,6 @@
 require 'rails'
 
-module MeiliSearch
+module Meilisearch
   module Rails
     class Railtie < ::Rails::Railtie
       rake_tasks do

data/lib/meilisearch/rails/tasks/meilisearch.rake

@@ -3,26 +3,26 @@ namespace :meilisearch do
   task reindex: :environment do
     puts 'Reindexing all Meilisearch models'
 
-    MeiliSearch::Rails::Utilities.reindex_all_models
+    Meilisearch::Rails::Utilities.reindex_all_models
   end
 
   desc 'Set settings to all indexes'
   task set_all_settings: :environment do
     puts 'Set settings in all Meilisearch models'
 
-    MeiliSearch::Rails::Utilities.set_settings_all_models
+    Meilisearch::Rails::Utilities.set_settings_all_models
   end
 
   desc 'Clear all indexes'
   task clear_indexes: :environment do
     puts 'Clearing indexes from all Meilisearch models'
 
-    MeiliSearch::Rails::Utilities.clear_all_indexes
+    Meilisearch::Rails::Utilities.clear_all_indexes
   end
 
   desc 'Create initializer file'
   task install: :environment do
-    puts 'Creating initializer file'
+    puts 'Writing initializer file at config/initializers/meilisearch.rb'
 
     copy_file "#{__dir__}/../templates/initializer.rb", 'config/initializers/meilisearch.rb'
   end

data/lib/meilisearch/rails/templates/initializer.rb

@@ -1,4 +1,4 @@
-MeiliSearch::Rails.configuration = {
+Meilisearch::Rails.configuration = {
   meilisearch_url: ENV.fetch('MEILISEARCH_HOST', 'http://localhost:7700'),
   meilisearch_api_key: ENV.fetch('MEILISEARCH_API_KEY', 'YourMeilisearchAPIKey')
 }

data/lib/meilisearch/rails/utilities.rb

@@ -1,4 +1,4 @@
-module MeiliSearch
+module Meilisearch
   module Rails
     module Utilities
       class << self
@@ -8,7 +8,7 @@ module MeiliSearch
           elsif ::Rails.application
             ::Rails.application.eager_load!
           end
-          klasses = MeiliSearch::Rails.instance_variable_get(:@included_in)
+          klasses = Meilisearch::Rails.instance_variable_get(:@included_in)
           (klasses + klasses.map(&:descendants).flatten).uniq
         end
 
@@ -48,6 +48,14 @@ module MeiliSearch
           true
         end
 
+        def mongo_model?(model_class)
+          defined?(::Mongoid::Document) && model_class.include?(::Mongoid::Document)
+        end
+
+        def sequel_model?(model_class)
+          defined?(::Sequel::Model) && model_class < Sequel::Model
+        end
+
         private
 
         def constraint_passes?(record, constraint)

data/lib/meilisearch/rails/version.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module MeiliSearch
+module Meilisearch
   module Rails
-    VERSION = '0.10.2'
+    VERSION = '0.16.0'
 
     def self.qualified_version
       "Meilisearch Rails (v#{VERSION})"