caoutsearch 0.0.1 → 0.0.3

data/lib/caoutsearch/search/internal_dsl.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  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,
+          suggestions: ActiveSupport::HashWithIndifferentAccess.new,
+          sorts: ActiveSupport::HashWithIndifferentAccess.new
+        }
+
+        class_attribute :aggregations, instance_accessor: false, default: {}
+        class_attribute :transformations, instance_accessor: false, default: {}
+      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 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 has_aggregation(name, **options, &block)
+          raise ArgumentError, "has_aggregation accepts options or block but not both" if block && options.any?
+
+          self.aggregations = aggregations.dup
+          aggregations[name.to_s] = Caoutsearch::Search::DSL::Item.new(name, options, &block)
+        end
+
+        def alias_aggregation(new_name, old_name)
+          has_aggregation(new_name) do |*args|
+            call_aggregation(old_name, *args)
+          end
+        end
+
+        def transform_aggregation(name, from: nil, track_total_hits: false, &block)
+          name = name.to_s
+          dependencies = Array.wrap(from).map(&:to_s)
+
+          raise ArgumentError, "block is missing" unless block
+
+          if aggregations.exclude?(name)
+            raise ArgumentError, "aggregation #{name} is missing, you may have to define :requires" if dependencies.empty?
+
+            has_aggregation(name) do |*args|
+              track_total_hits! if track_total_hits
+              dependencies.each do |dependency|
+                call_aggregation(dependency, *args)
+              end
+            end
+          end
+
+          self.transformations = transformations.dup
+          transformations[name.to_s] = Caoutsearch::Search::DSL::Item.new(name, {from: from}, &block)
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/naming.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  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

data/lib/caoutsearch/search/point_in_time.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module PointInTime
+      def open_point_in_time(index: index_name, keep_alive: "1m")
+        results = client.open_point_in_time(index: index, keep_alive: keep_alive)
+        results["id"]
+      end
+
+      def close_point_in_time(pit_id)
+        results = client.close_point_in_time(body: {id: pit_id})
+        results.body
+      rescue ::Elastic::Transport::Transport::Errors::NotFound
+        # We dont care if the PIT ID is already expired
+      end
+
+      def opened_points_in_time
+        results = client.indices.stats(index: index_name, metric: "search,shard_stats")
+
+        open_contexts = results.dig("_all", "total", "search", "open_contexts")
+        number_of_shards = results.dig("_all", "primaries", "shard_stats", "total_count")
+
+        open_contexts / number_of_shards
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/query/boolean.rb

@@ -5,7 +5,7 @@ module Caoutsearch
     module Query
       module Boolean
         def should_filter_on(terms)
-          terms              = flatten_bool_terms(:should, terms)
+          terms = flatten_bool_terms(:should, terms)
           terms_without_none = terms.without(Caoutsearch::Filter::NONE)
           return if terms.empty?
 
@@ -14,7 +14,7 @@ module Caoutsearch
           elsif terms_without_none.size == 1
             filters << terms_without_none[0]
           elsif terms_without_none.size > 1
-            filters << { bool: { should: terms_without_none } }
+            filters << {bool: {should: terms_without_none}}
           end
         end
 
@@ -38,9 +38,9 @@ module Caoutsearch
 
           filters <<
             if terms.size == 1
-              { bool: { must_not: terms[0] } }
+              {bool: {must_not: terms[0]}}
             else
-              filters << { bool: { must_not: terms } }
+              {bool: {must_not: terms}}
             end
         end
 

data/lib/caoutsearch/search/query/nested.rb

@@ -13,7 +13,7 @@ module Caoutsearch
             query = Caoutsearch::Search::Query::Base.new
             query[:path] = path.to_s
 
-            filters << { nested: query }
+            filters << {nested: query}
             query
           end
         end

data/lib/caoutsearch/search/query/setters.rb

@@ -30,7 +30,7 @@ module Caoutsearch
           filter_class = Caoutsearch::Filter[as]
           raise ArgumentError, "unexpected type of filter: #{as.inspect}" unless filter_class
 
-          terms = Array.wrap(keys).flat_map { |key| filter_class.new(key, value, type, options).as_json }
+          terms = Array.wrap(keys).flat_map { |key| filter_class.call(key, value, type, options) }
           terms.select(&:present?)
         rescue Caoutsearch::Search::ValueOverflow
           [Caoutsearch::Filter::NONE]
@@ -54,11 +54,11 @@ module Caoutsearch
         # Suggestions should probably use _source: false
         def add_suggestion(key, value, **options)
           suggestions[key] = {
-            prefix:     value,
+            prefix: value,
             completion: options.reverse_merge(
-              field:           key,
+              field: key,
               skip_duplicates: true,
-              fuzzy:           true
+              fuzzy: true
             )
           }
         end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module QueryBuilder
+      module Aggregations
+        private
+
+        def build_aggregations
+          call_aggregations(*current_aggregations) if current_aggregations
+        end
+
+        def call_aggregations(*args)
+          args.each do |arg|
+            if arg.is_a?(Hash)
+              arg.each do |key, value|
+                call_aggregation(key, value)
+              end
+            else
+              call_aggregation(arg)
+            end
+          end
+        end
+
+        def call_aggregation(name, *args)
+          name = name.to_s
+
+          if self.class.aggregations.include?(name)
+            item = self.class.aggregations[name]
+            call_aggregation_item(item, *args)
+          elsif self.class.aggregations.include?(:__default__)
+            block = self.class.aggregations[:__default__]
+            instance_exec(name, *args, &block)
+          else
+            raise "unexpected aggregation: #{name}"
+          end
+        end
+
+        def call_aggregation_item(item, *args)
+          if item.has_block?
+            instance_exec(*args, &item.block)
+          else
+            query.aggregations[item.name] = item.options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/query_builder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module QueryBuilder
+      extend ActiveSupport::Concern
+      include QueryBuilder::Aggregations
+
+      def build
+        reset_variable(:@elasticsearch_query)
+        reset_variable(:@nested_queries)
+
+        run_callbacks :build do
+          build_prepend_hash
+          build_search_criteria
+          build_context
+          build_defaults
+          build_limits
+          build_orders
+          build_aggregations
+          build_suggestions
+          build_fields
+          build_source
+          build_total_hits_tracking
+          build_append_hash
+        end
+
+        elasticsearch_query.clean
+        elasticsearch_query
+      end
+
+      private
+
+      def build_search_criteria
+        search_by(search_criteria)
+      end
+
+      def build_context
+        return unless current_context
+
+        item = config[:contexts][current_context.to_s]
+        instance_exec(&item.block) if item
+      end
+
+      def build_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 build_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 build_orders
+        return if current_limit.zero?
+
+        order_by(current_order || :default)
+      end
+
+      def build_suggestions
+        suggest_with(*current_suggestions) if current_suggestions
+      end
+
+      def build_fields
+        elasticsearch_query[:fields] = current_fields.map(&:to_s) if current_fields
+      end
+
+      def build_source
+        elasticsearch_query[:_source] = current_source unless current_source.nil?
+      end
+
+      def build_total_hits_tracking
+        elasticsearch_query[:track_total_hits] = @track_total_hits if @track_total_hits
+      end
+
+      def build_prepend_hash
+        elasticsearch_query.merge!(@prepend_hash) if @prepend_hash
+      end
+
+      def build_append_hash
+        elasticsearch_query.merge!(@append_hash) if @append_hash
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/query_methods.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module QueryMethods
+      delegate :merge, :merge!, :to_h, :to_json, :as_json, :filters,
+        :add_none, :add_filter, :add_sort, :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
+      alias_method :query, :elasticsearch_query
+
+      # 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 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

data/lib/caoutsearch/search/records.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Records
+      def records(use: nil, skip_query_cache: false)
+        if use
+          records_adapter.call(use, hits, skip_query_cache: skip_query_cache)
+        else
+          @records ||= records_adapter.call(model, hits)
+        end
+      end
+
+      def records_adapter
+        if defined?(ActiveRecord::Base)
+          Adapter::ActiveRecord
+        else
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/resettable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  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(:@raw_response)
+        reset_variable(:@response)
+        reset_variable(:@records)
+        reset_variable(:@total_count)
+        reset_variable(:@aggregations)
+        reset_variable(:@suggestions)
+        @loaded = false
+        self
+      end
+
+      private
+
+      def reset_variable(key)
+        remove_instance_variable(key) if instance_variable_defined?(key)
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/response.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Response
+      delegate :empty?, :size, :slice, :[], :to_a, :to_ary, to: :hits
+      delegate_missing_to :each
+
+      def load
+        @raw_response = perform_search_query(build.to_h)
+        @response = Caoutsearch::Response::Response.new(@raw_response)
+        @loaded = true
+        self
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def response
+        load unless loaded?
+        @response
+      end
+
+      def raw_response
+        load unless loaded?
+        @raw_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
+        response.dig("hits", "total")
+      end
+
+      def total_count
+        if !@track_total_hits && (!loaded? || response.dig("hits", "total", "relation") == "gte")
+          @total_count ||= spawn.track_total_hits!(true).source!(false).limit!(0).total_count
+        else
+          response.dig("hits", "total", "value")
+        end
+      end
+
+      def total_pages
+        (total_count.to_f / current_limit).ceil
+      end
+
+      def ids
+        hits.map { |hit| hit["_id"] }
+      end
+
+      def aggregations
+        @aggregations ||= Caoutsearch::Response::Aggregations.new(response.aggregations, self)
+      end
+
+      def suggestions
+        @suggestions ||= Caoutsearch::Response::Suggestions.new(response.suggest)
+      end
+
+      def each(&block)
+        return to_enum(:each) { hits.size } unless block
+
+        hits.each(&block)
+      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