esse 0.2.0 → 0.2.2

data/lib/esse/null_document.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Esse
+  class NullDocument < Esse::Serializer
+    def initialize
+      @object = nil
+      @options = {}
+    end
+
+    # @return [NilClass] the document ID
+    def id
+      nil
+    end
+
+    # @return [NilClass] the document type
+    def type
+      nil
+    end
+
+    # @return [NilClass] the document routing
+    def routing
+      nil
+    end
+
+    # @return [NilClass] the document meta
+    def meta
+      {}
+    end
+
+    # @return [NilClass] the document source
+    def source
+      nil
+    end
+  end
+end

data/lib/esse/plugins.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Esse
+  module Plugins
+    def self.inherited_instance_variables(mod, hash)
+      mod.send(:define_method, :inherited_instance_variables) do
+        super().merge!(hash)
+      end
+      mod.send(:private, :inherited_instance_variables)
+    end
+  end
+end

data/lib/esse/primitives/hstring.rb

@@ -9,7 +9,7 @@ module Esse
   class Hstring
     extend Forwardable
 
-    def_delegators :@value, :==, :eq, :to_s, :to_sym, :inspect, :sub, :capitalize
+    def_delegators :@value, :==, :eq, :to_s, :to_sym, :inspect, :sub, :capitalize, :tr
     attr_reader :value
 
     def self.def_conventional(bang_method, conv_method = nil)

data/lib/esse/{index_type → repository}/actions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Esse
-  class IndexType
+  class Repository
     module ClassMethods
       def action(name, options = {}, &block)
       end

data/lib/esse/{index_type → repository}/backend.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module Esse
-  class IndexType
+  class Repository
     module ClassMethods
       def elasticsearch
-        Esse::Backend::IndexType.new(self)
+        Esse::Backend::RepositoryBackend.new(self)
       end
       alias_method :backend, :elasticsearch
     end

data/lib/esse/repository/object_document_mapper.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Esse
+  # Delegates all the methods to the index ODM by prepending the type name.
+  #
+  # @see ObjectDocumentMapper
+  class Repository
+    module ClassMethods
+      # Convert ruby object to json. Arguments will be same of passed through the
+      # collection. It's allowed a block or a class with the `to_h` instance method.
+      # Example with block
+      #   serializer do |model, **context|
+      #     {
+      #       id: model.id,
+      #       admin: context[:is_admin],
+      #     }
+      #   end
+      # Example with serializer class
+      #   serializer UserSerializer
+      def serializer(klass = nil, &block)
+        if @serializer_proc
+          raise ArgumentError, format('Serializer for %p already defined', repo_name)
+        end
+
+        if block
+          @serializer_proc = ->(model, **kwargs) { coerce_to_document(block.call(model, **kwargs)) }
+        elsif klass.is_a?(Class) && klass <= Esse::Serializer
+          @serializer_proc = ->(model, **kwargs) { klass.new(model, **kwargs) }
+        elsif klass.is_a?(Class) && klass.instance_methods.include?(:to_h)
+          @serializer_proc = ->(model, **kwargs) { coerce_to_document(klass.new(model, **kwargs).to_h) }
+        elsif klass.is_a?(Class) && klass.instance_methods.include?(:as_json) # backward compatibility
+          @serializer_proc = ->(model, **kwargs) { coerce_to_document(klass.new(model, **kwargs).as_json) }
+        elsif klass.is_a?(Class) && klass.instance_methods.include?(:call)
+          @serializer_proc = ->(model, **kwargs) { coerce_to_document(klass.new(model, **kwargs).call) }
+        else
+          msg = format("%<arg>p is not a valid serializer. The serializer should inherit from Esse::Serializer or respond to `to_h'", arg: klass)
+          raise ArgumentError, msg
+        end
+      end
+
+      def coerce_to_document(value)
+        case value
+        when Esse::Serializer
+          value
+        when Hash
+          Esse::HashDocument.new(value)
+        when NilClass, FalseClass
+          Esse::NullDocument.new
+        else
+          raise ArgumentError, format('%<arg>p is not a valid document. The document should be a hash or an instance of Esse::Serializer', arg: value)
+        end
+      end
+
+      # Convert ruby object to json by using the serializer of the given document type.
+      # @param [Object] model The ruby object
+      # @param [Hash] kwargs The context
+      # @return [Esse::Document] The serialized document
+      def serialize(model, **kwargs)
+        if @serializer_proc.nil?
+          raise NotImplementedError, format('there is no %<t>p serializer defined for the %<k>p index', t: repo_name, k: index.to_s)
+        end
+
+        @serializer_proc.call(model, **kwargs)
+      end
+
+      # Used to define the source of data. A block is required. And its
+      # content should yield an array of each object that should be serialized.
+      # The list of arguments will be passed throught the serializer method.
+      #
+      # Example:
+      #   collection AdminStore
+      #   collection do |**conditions, &block|
+      #     User.where(conditions).find_in_batches(batch_size: 5000) do |batch|
+      #       block.call(batch, conditions)
+      #     end
+      #   end
+      #
+      # @param [String] name The identification of the collection.
+      # @param [Class] klass The class of the collection. (Optional when block is passed)
+      # @param [Proc] block The block that will be used to iterate over the collection. (Optional when using a class)
+      # @return [void]
+      def collection(collection_klass = nil, **_, &block)
+        if collection_klass.nil? && block.nil?
+          raise ArgumentError, 'a document type, followed by a collection class or block that stream the data ' \
+                              'is required to define the collection'
+        end
+
+        if block.nil? && collection_klass.is_a?(Class) && !collection_klass.include?(Enumerable)
+          msg = '%<arg>p is not a valid collection class.' \
+                ' Collections should implement the Enumerable interface.'
+          raise ArgumentError, format(msg, arg: collection_klass)
+        end
+
+        @collection_proc = collection_klass || block
+      end
+
+      # Used to fetch all batch of data defined on the collection model.
+      # Arguments can be anything. They will just be passed through the block.
+      # Useful when the collection depends on scope or any other conditions
+      #
+      # Example:
+      #   each_batch(active: true) do |data, **_collection_opts|
+      #     puts data.size
+      #   end
+      #
+      # @todo Remove *args. It should only support keyword arguments
+      #
+      # @param [Hash] kwargs The context
+      # @param [Proc] block The block that will be used to iterate over the collection.
+      # @return [void]
+      def each_batch(*args, **kwargs, &block)
+        if @collection_proc.nil?
+          raise NotImplementedError, format('there is no %<t>p collection defined for the %<k>p index', t: repo_name, k: index.to_s)
+        end
+
+        case @collection_proc
+        when Class
+          @collection_proc.new(*args, **kwargs).each(&block)
+        else
+          @collection_proc.call(*args, **kwargs, &block)
+        end
+      rescue LocalJumpError
+        raise(SyntaxError, 'block must be explicitly declared in the collection definition')
+      end
+
+      # Wrap collection data into serialized batches
+      #
+      # @param [Hash] kwargs The context
+      # @return [Enumerator] The enumerator
+      # @yield [Array, **context] serialized collection and the optional context from the collection
+      def each_serialized_batch(**kwargs, &block)
+        each_batch(**kwargs) do |*args|
+          batch, collection_context = args
+          collection_context ||= {}
+          entries = [*batch].map { |entry| serialize(entry, **collection_context) }.compact
+          block.call(entries, **kwargs)
+        end
+      end
+
+      # Wrap collection data into serialized documents
+      #
+      # Example:
+      #    GeosIndex.documents(id: 1).first
+      #
+      # @return [Enumerator] All serialized entries
+      def documents(**kwargs)
+        Enumerator.new do |yielder|
+          each_serialized_batch(**kwargs) do |docs, **_collection_kargs|
+            docs.each { |document| yielder.yield(document) }
+          end
+        end
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/repository.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Esse
+  # Type is actually deprecated. Elasticsearch today uses _doc instead of type
+  # And in upcoming release it will be totally removed.
+  # But I want to keep compatibility with old versions of es.
+  class Repository
+    class << self
+      # This methods will be defined using meta programming in the index respository definition
+      # @see Esse::Index::Type.repository
+      attr_reader :index
+      attr_accessor :document_type
+    end
+    require_relative 'repository/actions'
+    require_relative 'repository/backend'
+    require_relative 'repository/object_document_mapper'
+  end
+end

data/lib/esse/search/query.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Esse
+  module Search
+    class Query
+      attr_reader :client_proxy, :definition
+
+      # @param client_proxy [Esse::ClientProxy] The client proxy to use for the query
+      # @param indices [<Array<Esse::Index, String>] The class of the index to search or the index name
+      # @param definition [Hash] The options to pass to the search.
+      def initialize(client_proxy, *indices, suffix: nil, **definition, &_block)
+        @client_proxy = client_proxy
+        @definition = definition
+        @definition[:index] = indices.map do |index|
+          if index.is_a?(Class) && index < Esse::Index
+            index.index_name(suffix: suffix)
+          elsif index.is_a?(String) || index.is_a?(Symbol)
+            [index, suffix].compact.join('_')
+          else
+            raise ArgumentError, format('Invalid index type: %<index>p. It should be a Esse::Index class or a String index name', index: index)
+          end
+        end.join(',')
+      end
+
+      def response
+        @response ||= execute_search_query!
+      end
+
+      def results
+        return paginated_results if respond_to?(:paginated_results, true)
+
+        response.hits
+      end
+
+      def scroll_hits(batch_size: 1_000, scroll: '1m')
+        response = execute_search_query!(size: batch_size, scroll: scroll)
+        scroll_id = nil
+        fetched = 0
+        total = response.total
+
+        loop do
+          fetched += response.hits.size
+          yield(response.hits) if response.hits.any?
+          break if fetched >= total
+          scroll_id = response.raw_response['scroll_id'] || response.raw_response['_scroll_id']
+          break unless scroll_id
+          response = execute_scroll_query(scroll: scroll, scroll_id: scroll_id)
+        end
+      ensure
+        begin
+          client_proxy.clear_scroll(body: {scroll_id: scroll_id}) if scroll_id
+        rescue Esse::Backend::NotFoundError
+        end
+      end
+
+      private
+
+      def execute_search_query!(**execution_options)
+        resp, err = nil
+        Esse::Events.instrument('elasticsearch.execute_search_query') do |payload|
+          payload[:query] = self
+          begin
+            resp = Response.new(self, client_proxy.search(**definition, **execution_options))
+          rescue => e
+            err = e
+          end
+          payload[:error] = err if err
+          payload[:response] = resp
+        end
+        raise err if err
+
+        resp
+      end
+
+      def execute_scroll_query(scroll:, scroll_id:)
+        resp, err = nil
+        Esse::Events.instrument('elasticsearch.execute_search_query') do |payload|
+          payload[:query] = self
+          begin
+            resp = Response.new(self, client_proxy.scroll(scroll: scroll, body: { scroll_id: scroll_id }))
+          rescue => e
+            err = e
+          end
+          payload[:error] = err if err
+          payload[:response] = resp
+        end
+        raise err if err
+
+        resp
+      end
+
+      def reset!
+        @response = nil
+      end
+
+      def raw_limit_value
+        definition.dig(:body, :size) || definition.dig(:body, 'size') || definition.dig(:size) || definition.dig('size')
+      end
+
+      def raw_offset_value
+        definition.dig(:body, :from) || definition.dig(:body, 'from') || definition.dig(:from) || definition.dig('from')
+      end
+    end
+  end
+end

data/lib/esse/search/response.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Esse
+  module Search
+    class Response
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :hits, :each, :size, :empty?
+      attr_reader :query, :raw_response, :options
+
+      # @param [Esse::Search::Query] query The search query
+      # @param [Hash] raw_response The raw response from Elasticsearch
+      # @param [Hash] options The options passed to the search
+      def initialize(query, raw_response, **options)
+        @query = query
+        @raw_response = raw_response
+        @options = options
+      end
+
+      def shards
+        raw_response['_shards']
+      end
+
+      def aggregations
+        raw_response['aggregations']
+      end
+
+      def suggestions
+        raw_response['suggest']
+      end
+
+      def hits
+        raw_response.dig('hits', 'hits') || []
+      end
+
+      def total
+        if raw_response.dig('hits', 'total').respond_to?(:keys)
+          raw_response.dig('hits', 'total', 'value')
+        else
+          raw_response.dig('hits', 'total')
+        end.to_i
+      end
+    end
+  end
+end

data/lib/esse/serializer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Esse
+  class Serializer
+    attr_reader :object, :options
+
+    def initialize(object, **options)
+      @object = object
+      @options = options
+    end
+
+    # @return [String, Number] the document ID
+    # @abstract Override this method to return the document ID
+    def id
+      raise NotImplementedError, 'Override this method to return the document ID'
+    end
+
+    # @return [String, nil] the document type
+    # @abstract Override this method to return the document type
+    def type
+      nil
+    end
+
+    # @return [String, nil] the document routing
+    # @abstract Override this method to return the document routing
+    def routing
+      nil
+    end
+
+    # @return [Hash] the document meta
+    # @abstract Override this method to return the document meta
+    def meta
+      {}
+    end
+
+    # @return [Hash] the document source
+    # @abstract Override this method to return the document source
+    def source
+      {}
+    end
+
+    # @return [Hash] the document data
+    def to_h
+      source.merge(
+        _id: id,
+      ).tap do |hash|
+        hash[:_type] = type if type
+        hash[:_routing] = routing if routing
+        hash.merge!(meta)
+      end
+    end
+
+    def to_bulk(data: true)
+      { _id: id }.tap do |h|
+        h[:data] = source&.to_h if data
+        h[:_type] = type if type
+        h[:routing] = routing if routing
+        h.merge!(meta)
+      end
+    end
+
+    def ignore_on_index?
+      id.nil?
+    end
+
+    def ignore_on_delete?
+      id.nil?
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && (
+        id == other.id && type == other.type && routing == other.routing && meta == other.meta && source == other.source
+      )
+    end
+  end
+end

data/lib/esse/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Esse
-  VERSION = '0.2.0'
+  VERSION = '0.2.2'
 end

data/lib/esse.rb

@@ -1,12 +1,22 @@
 # frozen_string_literal: true
 
-require_relative 'esse/core'
-require_relative 'esse/errors'
-require_relative 'esse/index'
+require 'multi_json'
+require 'forwardable'
+
+begin
+  require 'elasticsearch'
+rescue LoadError
+end
+
+begin
+  require 'opensearch'
+rescue LoadError
+end
 
 module Esse
-  SETTING_ROOT_KEY = 'settings'
-  MAPPING_ROOT_KEY = 'mappings'
+  SETTING_ROOT_KEY = :settings
+  MAPPING_ROOT_KEY = :mappings
+  DEFAULT_REPO_NAME = 'default'
   CLI_IGNORE_OPTS = %i[
     require
     silent
@@ -17,3 +27,8 @@ module Esse
     config/initializers/esse.rb
   ].freeze
 end
+
+require_relative 'esse/plugins'
+require_relative 'esse/core'
+require_relative 'esse/errors'
+require_relative 'esse/index'

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: esse
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Marcos G. Zimmermann
-autorequire: 
+autorequire:
 bindir: exec
 cert_chain: []
-date: 2022-03-22 00:00:00.000000000 Z
+date: 2023-02-14 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: elasticsearch
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -235,8 +221,7 @@ files:
 - lib/esse/backend/index/refresh.rb
 - lib/esse/backend/index/reset.rb
 - lib/esse/backend/index/update.rb
-- lib/esse/backend/index_type.rb
-- lib/esse/backend/index_type/documents.rb
+- lib/esse/backend/repository_backend.rb
 - lib/esse/cli.rb
 - lib/esse/cli/base.rb
 - lib/esse/cli/event_listener.rb
@@ -252,41 +237,61 @@ files:
 - lib/esse/cli/index/update_aliases.rb
 - lib/esse/cli/index/update_mapping.rb
 - lib/esse/cli/index/update_settings.rb
+- lib/esse/cli/templates/collection.rb.erb
 - lib/esse/cli/templates/config.rb.erb
 - lib/esse/cli/templates/index.rb.erb
-- lib/esse/cli/templates/type_collection.rb.erb
-- lib/esse/cli/templates/type_mappings.json
-- lib/esse/cli/templates/type_serializer.rb.erb
+- lib/esse/cli/templates/mappings.json
+- lib/esse/cli/templates/serializer.rb.erb
+- lib/esse/cli/templates/settings.json
+- lib/esse/client_proxy.rb
+- lib/esse/client_proxy/search.rb
 - lib/esse/cluster.rb
+- lib/esse/cluster_engine.rb
+- lib/esse/collection.rb
 - lib/esse/config.rb
 - lib/esse/core.rb
+- lib/esse/deprecations.rb
+- lib/esse/deprecations/cluster.rb
+- lib/esse/deprecations/index.rb
+- lib/esse/deprecations/repository.rb
+- lib/esse/dynamic_template.rb
 - lib/esse/errors.rb
 - lib/esse/events.rb
 - lib/esse/events/bus.rb
 - lib/esse/events/event.rb
 - lib/esse/events/publisher.rb
+- lib/esse/hash_document.rb
+- lib/esse/import/bulk.rb
+- lib/esse/import/request_body.rb
 - lib/esse/index.rb
 - lib/esse/index/actions.rb
+- lib/esse/index/attributes.rb
 - lib/esse/index/backend.rb
 - lib/esse/index/base.rb
 - lib/esse/index/descendants.rb
 - lib/esse/index/inheritance.rb
 - lib/esse/index/mappings.rb
-- lib/esse/index/naming.rb
+- lib/esse/index/object_document_mapper.rb
+- lib/esse/index/plugins.rb
+- lib/esse/index/search.rb
 - lib/esse/index/settings.rb
 - lib/esse/index/type.rb
 - lib/esse/index_mapping.rb
 - lib/esse/index_setting.rb
-- lib/esse/index_type.rb
-- lib/esse/index_type/actions.rb
-- lib/esse/index_type/backend.rb
-- lib/esse/index_type/mappings.rb
 - lib/esse/logging.rb
-- lib/esse/object_document_mapper.rb
+- lib/esse/null_document.rb
+- lib/esse/plugins.rb
 - lib/esse/primitives.rb
 - lib/esse/primitives/hash_utils.rb
 - lib/esse/primitives/hstring.rb
 - lib/esse/primitives/output.rb
+- lib/esse/repository.rb
+- lib/esse/repository/actions.rb
+- lib/esse/repository/backend.rb
+- lib/esse/repository/object_document_mapper.rb
+- lib/esse/search/query.rb
+- lib/esse/search/response.rb
+- lib/esse/serializer.rb
 - lib/esse/template_loader.rb
 - lib/esse/version.rb
 homepage: https://github.com/marcosgz/esse
@@ -296,7 +301,7 @@ metadata:
   homepage_uri: https://github.com/marcosgz/esse
   source_code_uri: https://github.com/marcosgz/esse
   changelog_uri: https://github.com/marcosgz/esse/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -312,7 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3.1
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Pure Ruby toolkit based on official elasticsearch-ruby library. (No! It isn't
   a new DSL)