caoutsearch 0.0.0

data/lib/caoutsearch/instrumentation/index.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Instrumentation
+    class Index < Base
+      def get(event)
+        log_request("Get", event, format: log_request_format)
+        log_response("Get", event)
+      end
+
+      def index(event)
+        log_request("Index", event, format: log_request_format)
+        log_response("Index", event)
+      end
+
+      def update(event)
+        log_request("Update", event, format: log_request_format)
+        log_response("Update", event)
+      end
+
+      def delete(event)
+        log_request("Delete", event, format: log_request_format)
+        log_response("Delete", event)
+      end
+
+      def bulk(event)
+        method = event[:method].to_s.titleize
+
+        log_request("Bulk #{method}", event, format: log_request_format)
+        log_response("Bulk #{method}", event, warn_errors: true)
+      end
+
+      def reindex(event)
+        log_request("Reindex", event, format: log_request_format)
+        log_response("Reindex", event, warn_errors: true) do |message|
+          payload = event.payload
+          request = payload[:request]
+          request_size = inspect_json_size(request)
+
+          response = payload[:response]
+          response_size = inspect_json_size(response)
+
+          message += ", request size: #{request_size}"
+          message += ", response size: #{response_size}"
+          message += ", progress: #{payload[:progress]} / #{payload[:total]}"
+          message
+        end
+      end
+
+      private
+
+      def log_request_format
+        Caoutsearch.instrumentation_options[:index]
+      end
+    end
+  end
+end

data/lib/caoutsearch/instrumentation/search.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Instrumentation
+    class Search < Base
+      def search(event)
+        log_request("Search", event, format: log_request_format)
+        log_response("Search", event)
+      end
+
+      def scroll_search(event)
+        log_request("Search", event, format: log_request_format)
+        log_response("Search", event) do |message|
+          payload  = event.payload
+          message += ", progress: #{payload[:progress]} / #{payload[:total]}"
+          message
+        end
+      end
+
+      def scroll(event)
+        log_request("Scroll", event, format: "truncated")
+        log_response("Scroll", event) do |message|
+          payload  = event.payload
+          message += ", progress: #{payload[:progress]} / #{payload[:total]}"
+          message
+        end
+      end
+
+      def delete(event)
+        log_request("Delete", event, format: log_request_format)
+        log_response("Delete", event)
+      end
+
+      private
+
+      def log_request_format
+        Caoutsearch.instrumentation_options[:search]
+      end
+    end
+  end
+end

data/lib/caoutsearch/mappings.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  class Mappings
+    attr_reader :index_name
+
+    # Build an index mapping
+    #
+    #   Caoutsearch::Mapping.new({ properties: [...], )
+    #
+    def initialize(mappings)
+      @mappings = mappings.deep_symbolize_keys
+    end
+
+    def to_hash
+      @mappings
+    end
+    alias_method :as_json, :to_hash
+
+    def to_json(*)
+      as_json.to_json
+    end
+
+    def include?(*args)
+      find(*args).present?
+    end
+
+    def find(*args)
+      each_path(*args).map { |hash, _| hash }.last
+    end
+
+    def find_type(*args)
+      definition = find(*args)
+      definition[:type]&.to_s if definition.present?
+    end
+
+    def nested?(*args)
+      nested_path(*args).present?
+    end
+
+    def include_in_parent?(*args)
+      path = nested_path(*args)
+      return nil unless path
+
+      !!find(path)[:include_in_parent]
+    end
+
+    def nested_path(*args)
+      return nil unless include?(*args)
+
+      each_path(*args) do |hash, current_path|
+        break nil unless hash
+        return current_path if hash[:type] == "nested"
+      end
+
+      nil
+    end
+
+    private
+
+    def key_path(*args)
+      args.flat_map { |path| path.to_s.split(".").map(&:to_sym) }
+    end
+
+    def each_path(*args)
+      return to_enum(:each_path, *args) unless block_given?
+
+      hash = to_hash
+      path = []
+
+      key_path(*args).each do |key|
+        path << key
+        hash = hash.dig(:properties, key) || hash.dig(:fields, key) if hash
+
+        yield hash, path.join(".")
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    class Base
+      include Caoutsearch::Config::Client
+      include Caoutsearch::Config::Mappings
+      include Caoutsearch::Config::Settings
+
+      include Caoutsearch::Search::Search::DeleteMethods
+      include Caoutsearch::Search::Search::Inspect
+      include Caoutsearch::Search::Search::Instrumentation
+      include Caoutsearch::Search::Search::InternalDSL
+      include Caoutsearch::Search::Search::Naming
+      include Caoutsearch::Search::Search::QueryBuilder
+      include Caoutsearch::Search::Search::QueryMethods
+      include Caoutsearch::Search::Search::Resettable
+      include Caoutsearch::Search::Search::Response
+      include Caoutsearch::Search::Search::ScrollMethods
+      include Caoutsearch::Search::Search::SearchMethods
+
+      def self.search(*args)
+        new.search(*args)
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/dsl/item.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module DSL
+      class Item
+        attr_reader :name, :options, :block
+
+        PROPERTIES_TO_INSPECT = %i[name options block].freeze
+
+        def initialize(name, options = {}, &block)
+          @name    = name
+          @options = options
+          @block   = block if block
+        end
+
+        def has_block?
+          block.present?
+        end
+
+        def indexes
+          @indexes ||= Array.wrap(options[:indexes].presence || name)
+        end
+
+        def inspect
+          properties = properties_to_inspect.map { |k, v| " #{k}: #{v}" }
+
+          "#<#{self.class}#{properties.join(",")}>"
+        end
+
+        private
+
+        def properties_to_inspect
+          PROPERTIES_TO_INSPECT.each_with_object({}) do |name, properties|
+            value = instance_variable_get("@#{name}")
+            properties[name] = value.inspect if value.present?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      class Base < ::Hash
+        include Caoutsearch::Search::Query::Boolean
+        include Caoutsearch::Search::Query::Cleaning
+        include Caoutsearch::Search::Query::Getters
+        include Caoutsearch::Search::Query::Merge
+        include Caoutsearch::Search::Query::Nested
+        include Caoutsearch::Search::Query::Setters
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      module Boolean
+        def should_filter_on(terms)
+          terms              = flatten_bool_terms(:should, terms)
+          terms_without_none = terms.without(Caoutsearch::Filter::NONE)
+          return if terms.empty?
+
+          if terms.size == 1
+            filters << terms[0]
+          elsif terms_without_none.size == 1
+            filters << terms_without_none[0]
+          elsif terms_without_none.size > 1
+            filters << { bool: { should: terms_without_none } }
+          end
+        end
+
+        def must_filter_on(terms)
+          terms = flatten_bool_terms(:must, terms)
+          return if terms.empty?
+
+          if terms.include?(Caoutsearch::Filter::NONE)
+            filters << Caoutsearch::Filter::NONE
+          elsif terms.size == 1
+            filters << terms[0]
+          elsif terms.size > 1
+            filters.push(*terms)
+          end
+        end
+
+        def must_not_filter_on(terms)
+          terms = flatten_bool_terms(:must_not, terms)
+          terms = terms.without(Caoutsearch::Filter::NONE)
+          return if terms.empty?
+
+          filters <<
+            if terms.size == 1
+              { bool: { must_not: terms[0] } }
+            else
+              filters << { bool: { must_not: terms } }
+            end
+        end
+
+        def flatten_bool_terms(operator, raw_terms)
+          terms = []
+
+          raw_terms.flatten.each do |value|
+            if value.is_a?(Hash) && value.keys == [:bool] && value[:bool].keys == [operator]
+              terms += Array.wrap(value.dig(:bool, operator))
+            else
+              terms << value
+            end
+          end
+
+          terms.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      module Cleaning
+        def clean
+          nested_queries.each_value(&:clean)
+          remove_duplicate_filters
+          remove_empty_clauses
+          self
+        end
+
+        def remove_duplicate_filters
+          filters.replace(filters.uniq) if dig(:query, :bool, :filter)
+          self
+        end
+
+        def remove_empty_clauses
+          each do |key, value|
+            delete(key) if value.blank? && value != false
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      module Getters
+        def filters
+          fetch(:query, :bool, :filter, [])
+        end
+
+        def aggregations
+          fetch(:aggregations, {})
+        end
+
+        def suggestions
+          fetch(:suggest, {})
+        end
+
+        def sort
+          fetch(:sort, [])
+        end
+
+        def fetch(*keys, default_value)
+          value = self
+
+          keys[0..-2].each do |key|
+            value = value[key] ||= {}
+          end
+
+          value[keys[-1]] ||= default_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      module Merge
+        def merge(other_hash)
+          dup.merge!(other_hash)
+        end
+
+        def merge!(other_hash)
+          merged_hash = to_h.deep_merge(other_hash) do |key, this_val, other_val|
+            if this_val.is_a?(Array) && other_val.is_a?(Array)
+              (this_val + other_val).uniq
+            elsif block_given?
+              yield key, this_val, other_val
+            else
+              other_val
+            end
+          end
+
+          super(merged_hash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      module Nested
+        def nested_queries
+          @nested_queries ||= {}
+        end
+
+        def nested_query(path)
+          nested_queries[path.to_s] ||= begin
+            query = Caoutsearch::Search::Query::Base.new
+            query[:path] = path.to_s
+
+            filters << { nested: query }
+            query
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Query
+      module Setters
+        def add_none
+          filters << Caoutsearch::Filter::NONE
+        end
+
+        def add_filter(...)
+          should_filter_on(build_terms(...))
+          self
+        end
+
+        # Compose filters
+        #
+        # Examples :
+        #
+        #   query.build_terms('key', 'value')
+        #   => [ { term: { "key" => "value" } } ] } } }
+        #
+        #   query.build_terms('key', 'value', type: :integer)
+        #   => [ { term: { "key" => 0 } } ] } } }
+        #
+        #   query.build_terms('key', 'value', as: :boolean)
+        #   => [ { term: { "key" => true } } ] } } }
+        #
+        def build_terms(keys, value, type: :keyword, as: :default, **options)
+          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.select(&:present?)
+        rescue Caoutsearch::Search::ValueOverflow
+          [Caoutsearch::Filter::NONE]
+        end
+
+        def add_sort(prop, direction)
+          if direction.to_s == "desc"
+            sort.push(prop => direction)
+          else
+            sort.push(prop)
+          end
+          self
+        end
+
+        def add_aggregation(key, value)
+          aggregations[key] = value
+        end
+
+        # TODO,
+        # Handle types, ex: prefix, input, text
+        # Suggestions should probably use _source: false
+        def add_suggestion(key, value, **options)
+          suggestions[key] = {
+            prefix:     value,
+            completion: options.reverse_merge(
+              field:           key,
+              skip_duplicates: true,
+              fuzzy:           true
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/sanitizer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Sanitizer
+      ESCAPED_CHARACTERS        = "\+-&|!(){}[]^~*?:"
+      ESCAPED_CHARACTERS_REGEXP = /([+\-&|!(){}\[\]\^~*?:])/
+
+      class << self
+        def sanitize(value, characters = ESCAPED_CHARACTERS)
+          case value
+          when Array
+            value.map { |v| sanitize(v) }
+          when Hash
+            value.each { |k, v| value[k] = sanitize(v) }
+          when String
+            regexp   = ESCAPED_CHARACTERS_REGEXP if characters == ESCAPED_CHARACTERS
+            regexp ||= Regexp.new("([#{Regexp.escape(characters)}])")
+
+            value.gsub(regexp, '\\\\\1')
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/delete_methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module DeleteMethods
+        def delete_documents
+          request_payload = {
+            index:  index_name,
+            body:   build.to_h
+          }
+
+          instrument(:delete) do |event_payload|
+            event_payload[:request]  = request_payload
+            event_payload[:response] = client.delete_by_query(request_payload)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/inspect.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module Inspect
+        PROPERTIES_TO_INSPECT = %i[
+          search_criteria
+          current_context
+          current_order
+          current_page
+          current_limit
+          current_offset
+          current_aggregations
+          current_suggestions
+          current_returns
+        ].freeze
+
+        def inspect
+          properties = properties_to_inspect.map { |k, v| " #{k}: #{v}" }
+
+          "#<#{self.class}#{properties.join(",")}>"
+        end
+
+        private
+
+        def properties_to_inspect
+          PROPERTIES_TO_INSPECT.each_with_object({}) do |name, properties|
+            value = instance_variable_get("@#{name}")
+            properties[name] = value.inspect if value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/caoutsearch/search/search/instrumentation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Caoutsearch
+  module Search
+    module Search
+      module Instrumentation
+        extend ActiveSupport::Concern
+
+        def instrument(action, **options, &block)
+          ActiveSupport::Notifications.instrument("#{action}.caoutsearch_search", **options, klass: self.class.to_s, &block)
+        end
+
+        class_methods do
+          def instrument(action, **options, &block)
+            ActiveSupport::Notifications.instrument("#{action}.caoutsearch_search", **options, klass: to_s, &block)
+          end
+        end
+      end
+    end
+  end
+end