caoutsearch 0.0.0

data/lib/caoutsearch/search/search/internal_dsl.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module InternalDSL
+        extend ActiveSupport::Concern
+
+        included do
+          # Do to not make:
+          #   self.config[:filter][key] = ...
+          #
+          # Changing only config members will lead to inheritance issue.
+          # Instead, make:
+          #   self.config = config.deep_dup
+          #   self.config[:filter][key] = ...
+          #
+          class_attribute :config, default: {
+            contexts:     ActiveSupport::HashWithIndifferentAccess.new,
+            filters:      ActiveSupport::HashWithIndifferentAccess.new,
+            defaults:     ActiveSupport::HashWithIndifferentAccess.new,
+            aggregations: ActiveSupport::HashWithIndifferentAccess.new,
+            suggestions:  ActiveSupport::HashWithIndifferentAccess.new,
+            sorts:        ActiveSupport::HashWithIndifferentAccess.new
+          }
+        end
+
+        class_methods do
+          def match_all(&block)
+            self.config = config.deep_dup
+            config[:match_all] = block
+          end
+
+          %w[context default].each do |method|
+            config_attribute = method.pluralize.to_sym
+
+            define_method method do |name = nil, &block|
+              self.config = config.deep_dup
+
+              if name
+                config[config_attribute][name] = Caoutsearch::Search::DSL::Item.new(name, &block)
+              else
+                config[config_attribute][:__undef__] = block
+              end
+            end
+          end
+
+          %w[filter aggregation sort suggestion].each do |method|
+            config_attribute = method.pluralize.to_sym
+
+            define_method method do |name = nil, **options, &block|
+              self.config = config.deep_dup
+
+              if name
+                config[config_attribute][name.to_s] = Caoutsearch::Search::DSL::Item.new(name, options, &block)
+              else
+                config[config_attribute][:__undef__] = block
+              end
+            end
+          end
+
+          def alias_filter(new_name, old_name)
+            filter(new_name) { |value| search_by(old_name => value) }
+          end
+
+          def alias_sort(new_name, old_name)
+            sort(new_name) { |direction| sort_by(old_name, direction) }
+          end
+
+          def alias_aggregation(new_name, old_name)
+            aggregation(new_name) { aggregate_with(old_name) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/naming.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module Naming
+        extend ActiveSupport::Concern
+
+        included do
+          delegate :model, :model_name, :index_name, to: :class
+        end
+
+        class_methods do
+          def model
+            @model ||= model_name.constantize
+          end
+
+          def model_name
+            @model_name ||= defaut_model_name
+          end
+
+          def model_name=(name)
+            @model_name = name
+          end
+
+          def index_name
+            @index_name ||= default_index_name
+          end
+
+          def index_name=(name)
+            @index_name = name
+          end
+
+          private
+
+          def default_index_name
+            name.gsub(/Search$/, "").tableize.tr("/", "_")
+          end
+
+          def defaut_model_name
+            name.gsub(/Search$/, "")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/query_builder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module QueryBuilder
+        extend ActiveSupport::Concern
+
+        included do
+          include ActiveSupport::Callbacks
+          define_callbacks :build
+        end
+
+        def build
+          run_callbacks :build do
+            apply_prepend_hash
+            apply_search_criteria
+            apply_context
+            apply_defaults
+            apply_limits
+            apply_orders
+            apply_aggregations
+            apply_suggestions
+            apply_fields
+            apply_source
+            apply_total_hits_tracking
+            apply_append_hash
+          end
+
+          elasticsearch_query.clean
+          elasticsearch_query
+        end
+
+        def apply_search_criteria
+          search_by(search_criteria)
+        end
+
+        def apply_context
+          return unless current_context
+
+          item = config[:contexts][current_context.to_s]
+          instance_exec(&item.block) if item
+        end
+
+        def apply_defaults
+          keys = search_criteria_keys.map(&:to_s)
+
+          config[:defaults].each do |key, item|
+            instance_exec(&item.block) unless keys.include?(key.to_s)
+          end
+        end
+
+        def apply_limits
+          elasticsearch_query[:size] = current_limit.to_i if @current_page || @current_limit
+          elasticsearch_query[:from] = current_offset     if @current_page || @current_offset
+        end
+
+        def apply_orders
+          return if current_limit.zero?
+
+          order_by(current_order || :default)
+        end
+
+        def apply_aggregations
+          aggregate_with(*current_aggregations) if current_aggregations
+        end
+
+        def apply_suggestions
+          suggest_with(*current_suggestions) if current_suggestions
+        end
+
+        def apply_fields
+          elasticsearch_query[:fields] = current_fields.map(&:to_s) if current_fields
+        end
+
+        def apply_source
+          elasticsearch_query[:_source] = current_source unless current_source.nil?
+        end
+
+        def apply_total_hits_tracking
+          elasticsearch_query[:track_total_hits] = @track_total_hits if @track_total_hits
+        end
+
+        def apply_prepend_hash
+          elasticsearch_query.merge!(@prepend_hash) if @prepend_hash
+        end
+
+        def apply_append_hash
+          elasticsearch_query.merge!(@append_hash) if @append_hash
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/query_methods.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module QueryMethods
+        delegate :merge, :merge!, :to_h, :to_json, :as_json, :filters,
+          :add_none, :add_filter, :add_sort, :add_aggregation, :add_suggestion,
+          :build_terms, :should_filter_on, :must_filter_on, :must_not_filter_on,
+          :nested_queries, :nested_query,
+          to: :elasticsearch_query
+
+        # Accessors
+        # ------------------------------------------------------------------------
+        def elasticsearch_query
+          @elasticsearch_query ||= Caoutsearch::Search::Query::Base.new
+        end
+
+        # Applying criteria
+        # ------------------------------------------------------------------------
+        def search_by(criteria)
+          case criteria
+          when Array  then criteria.each { |criterion| search_by(criterion) }
+          when Hash   then criteria.each { |key, value| filter_by(key, value) }
+          when String then apply_dsl_match_all(criteria)
+          end
+        end
+
+        def filter_by(key, value)
+          case key
+          when Array
+            items = key.filter_map { |k| config[:filters][k] }
+            apply_dsl_filters(items, value)
+          when Caoutsearch::Search::DSL::Item
+            apply_dsl_filter(key, value)
+          else
+            if config[:filters].key?(key)
+              apply_dsl_filter(config[:filters][key], value)
+            elsif config[:filters].key?(:__undef__)
+              block = config[:filters][:__undef__]
+              instance_exec(key, value, &block)
+            end
+          end
+        end
+
+        # Applying DSL filters items
+        # ------------------------------------------------------------------------
+        def apply_dsl_match_all(value)
+          return unless (block = config[:match_all])
+
+          instance_exec(value, &block)
+        end
+
+        def apply_dsl_filter(item, value)
+          return instance_exec(value, &item.block) if item.has_block?
+
+          terms   = []
+          indexes = item.indexes
+          options = item.options.dup
+          query   = elasticsearch_query
+
+          if options[:nested_query]
+            query = nested_query(options[:nested_query])
+            options[:nested] = nil
+          end
+
+          indexes.each do |index|
+            options_index = options.dup
+            options_index[:type]              = mappings.find_type(index)          unless options_index.key?(:type)
+            options_index[:nested]            = mappings.nested_path(index)        unless options_index.key?(:nested)
+            options_index[:include_in_parent] = mappings.include_in_parent?(index) unless options_index.key?(:include_in_parent) || !options_index[:nested]
+
+            terms += query.build_terms(index, value, **options_index)
+          end
+
+          query.should_filter_on(terms)
+        end
+
+        def apply_dsl_filters(items, value)
+          terms = []
+
+          items.each do |item|
+            terms += isolate_dsl_filter(item, value)
+          end
+
+          should_filter_on(terms)
+        end
+
+        def isolate_dsl_filter(item, value)
+          isolated_instance = clone
+          isolated_instance.apply_dsl_filter(item, value)
+          isolated_instance.elasticsearch_query.dig(:query, :bool, :filter) || []
+        end
+
+        # Applying orders
+        # ------------------------------------------------------------------------
+        def order_by(keys)
+          case keys
+          when Array          then keys.each { |key| order_by(key) }
+          when Hash           then keys.each { |key, direction| sort_by(key, direction) }
+          when String, Symbol then sort_by(keys)
+          end
+        end
+
+        def sort_by(key, direction = nil)
+          if config[:sorts].key?(key)
+            apply_dsl_sort(config[:sorts][key], direction)
+          elsif config[:sorts].key?(:__undef__)
+            block = config[:sorts][:__undef__]
+            instance_exec(key, direction, &block)
+          end
+        end
+
+        def apply_dsl_sort(item, direction)
+          return instance_exec(direction, &item.block) if item.has_block?
+
+          indexes = item.indexes
+          indexes.each do |index|
+            case index
+            when :default, "default"
+              sort_by(:default, direction)
+
+            when Hash
+              index.map do |key, value|
+                key_direction = (value.to_s == direction.to_s ? :asc : :desc)
+                add_sort(key, key_direction)
+              end
+
+            else
+              add_sort(index, direction)
+            end
+          end
+        end
+
+        # Applying aggregations
+        # ------------------------------------------------------------------------
+        def aggregate_with(*args)
+          args.each do |arg|
+            if arg.is_a?(Hash)
+              arg.each do |key, value|
+                next unless (item = config[:aggregations][key])
+
+                apply_dsl_aggregate(item, value)
+              end
+            elsif (item = config[:aggregations][arg])
+              apply_dsl_aggregate(item)
+            end
+          end
+        end
+
+        def apply_dsl_aggregate(item, *args)
+          return instance_exec(*args, &item.block) if item.has_block?
+
+          add_aggregation(item.name, item.options)
+        end
+
+        # Applying Suggests
+        # ------------------------------------------------------------------------
+        def suggest_with(*args)
+          args.each do |(hash, options)|
+            raise ArgumentError unless hash.is_a?(Hash)
+
+            hash.each do |key, value|
+              next unless (item = config[:suggestions][key.to_s])
+
+              options ||= {}
+              apply_dsl_suggest(item, value, **options)
+            end
+          end
+        end
+
+        def apply_dsl_suggest(item, query, **options)
+          return instance_exec(query, **options, &item.block) if item.has_block?
+
+          add_suggestion(item.name, query, **options)
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/resettable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module Resettable
+        def spawn
+          clone
+        end
+
+        def clone
+          super.reset
+        end
+
+        def dup
+          super.reset
+        end
+
+        def reset
+          reset_variable(:@elasticsearch_query)
+          reset_variable(:@nested_queries)
+          reset_variable(:@response)
+          reset_variable(:@total_count)
+          self
+        end
+
+        private
+
+        def reset_variable(key)
+          remove_instance_variable(key) if instance_variable_defined?(key)
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/response.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module Response
+        delegate :empty?, :size, :slice, :[], :to_a, :to_ary, to: :hits
+        delegate_missing_to :each
+
+        def response
+          load unless @response
+          @response
+        end
+
+        def took
+          response["took"]
+        end
+
+        def timed_out
+          response["timed_out"]
+        end
+
+        def shards
+          response["_shards"]
+        end
+
+        def hits
+          response.dig("hits", "hits")
+        end
+
+        def max_score
+          response.dig("hits", "max_score")
+        end
+
+        def total_count
+          if response.dig("hits", "total", "relation") == "gte" && !@track_total_hits
+            @total_count ||= spawn.track_total_hits(true).total_count
+          else
+            response.dig("hits", "total", "value")
+          end
+        end
+
+        def total_pages
+          (total_count.to_f / current_limit).ceil
+        end
+
+        def ids
+          hits.pluck("_id")
+        end
+
+        def aggregations
+          # TODO
+        end
+
+        def suggestions
+          # TODO
+        end
+
+        def records
+          model.where(model.primary_key => ids)
+        end
+
+        def each(&block)
+          return to_enum(:each) { hits.size } unless block
+
+          hits.each(&block)
+        end
+
+        def load
+          @response = perform_search_query(build.to_h)
+          self
+        end
+
+        def perform_search_query(query)
+          request_payload = {
+            index:  index_name,
+            body:   query
+          }
+
+          instrument(:search) do |event_payload|
+            event_payload[:request]  = request_payload
+            event_payload[:response] = client.search(request_payload)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/scroll_methods.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module ScrollMethods
+        def scroll(scroll: "1h", &block)
+          return to_enum(scroll, scroll: scroll) unless block
+
+          request_payload = {
+            index:  index_name,
+            scroll: scroll,
+            body:   build.to_h
+          }
+
+          total              = 0
+          progress           = 0
+          requested_at       = nil
+          last_response_time = nil
+
+          results = instrument(:scroll_search) do |event_payload|
+            response           = client.search(request_payload)
+            last_response_time = Time.current
+
+            total     = response["hits"]["total"]["value"]
+            progress += response["hits"]["hits"].size
+
+            event_payload[:request]  = request_payload
+            event_payload[:response] = response
+            event_payload[:total]    = total
+            event_payload[:progress] = progress
+
+            response
+          end
+
+          scroll_id = results["_scroll_id"]
+          hits      = results["hits"]["hits"]
+
+          yield hits, { progress: progress, total: total, scroll_id: scroll_id }
+
+          while progress < total
+            request_payload = {
+              scroll_id: scroll_id,
+              scroll:    scroll
+            }
+
+            requested_at = Time.current
+
+            results = instrument(:scroll, scroll: scroll_id) do |event_payload|
+              response           = client.scroll(request_payload)
+              last_response_time = Time.current
+
+              total     = response["hits"]["total"]["value"]
+              progress += response["hits"]["hits"].size
+
+              event_payload[:request]  = request_payload
+              event_payload[:response] = response
+              event_payload[:total]    = total
+              event_payload[:progress] = progress
+
+              response
+            rescue Elastic::Transport::Transport::Errors::NotFound => e
+              raise_enhance_message_when_scroll_failed(e, scroll, requested_at, last_response_time)
+            end
+
+            hits       = results["hits"]["hits"]
+            progress  += hits.size
+
+            break if hits.empty?
+
+            yield hits, { progress: progress, total: total, scroll_id: scroll_id }
+          end
+
+          total
+        ensure
+          clear_scroll(scroll_id) if scroll_id
+        end
+
+        def clear_scroll(scroll_id)
+          client.clear_scroll(scroll_id: scroll_id)
+        rescue ::Elastic::Transport::Transport::Errors::NotFound
+          # We dont care if the scroll ID is already expired
+        end
+
+        def scroll_records_in_batches(**options)
+          return to_enum(:scroll_records_in_batches, **options) unless block_given?
+
+          scroll(**options) do |hits|
+            ids = hits.map { |doc| doc["_id"] }
+            yield model.where(id: ids)
+            model.connection.clear_query_cache
+          end
+        end
+
+        def scroll_records(**options, &block)
+          return to_enum(:scroll_records, **options) unless block
+
+          scroll_records_in_batches(**options) do |relation|
+            relation.each(&block)
+          end
+        end
+
+        private
+
+        def raise_enhance_message_when_scroll_failed(error, scroll, requested_at, last_response_time)
+          elapsed = (requested_at - last_response_time).round(1).seconds
+
+          raise error.exception("Scroll registered for #{scroll}, #{elapsed.inspect} elapsed between. #{error.message}")
+        end
+      end
+    end
+  end
+end