esse 0.2.0 → 0.2.2

data/lib/esse/backend/index_type/documents.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-module Esse
-  module Backend
-    class IndexType
-      module InstanceMethods
-        # Resolve collection and index data
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @option [Hash] :context The collection context. This value will be passed as argument to the collection
-        #   May be SQL condition or any other filter you have defined on the collection.
-        def import(context: {}, suffix: nil, **options)
-          each_serialized_batch(**(context || {})) do |batch|
-            bulk(index: batch, suffix: suffix, **options)
-          end
-        end
-        alias_method :import!, :import
-
-        # Performs multiple indexing or delete operations in a single API call.
-        # This reduces overhead and can greatly increase indexing speed.
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @option [Array] :index list of serialized documents to be indexed(Optional)
-        # @option [Array] :delete list of serialized documents to be deleted(Optional)
-        # @option [Array] :create list of serialized documents to be created(Optional)
-        # @return [Hash, nil] the elasticsearch response or nil if there is no data.
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-bulk.html
-        def bulk(index: nil, delete: nil, create: nil, suffix: nil, **options)
-          body = []
-          Array(index).each do |entry|
-            id, data = Esse.doc_id!(entry)
-            body << { index: { _id: id, data: data } } if id
-          end
-          Array(create).each do |entry|
-            id, data = Esse.doc_id!(entry)
-            body << { create: { _id: id, data: data } } if id
-          end
-          Array(delete).each do |entry|
-            id, _data = Esse.doc_id!(entry, delete: [], keep: %w[_id id])
-            body << { delete: { _id: id } } if id
-          end
-
-          return if body.empty?
-
-          definition = {
-            index: index_name(suffix: suffix),
-            type: type_name,
-            body: body,
-          }.merge(options)
-
-          client.bulk(definition)
-        end
-        alias_method :bulk!, :bulk
-
-        # Adds a JSON document to the specified index and makes it searchable. If the document
-        # already exists, updates the document and increments its version.
-        #
-        #   UsersIndex::User.index(id: 1, body: { name: 'name' }) # { '_id' => 1, ...}
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [Hash] :body The JSON document that will be indexed (Required)
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @return [Hash] the elasticsearch response Hash
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-index_.html
-        def index(id:, body:, suffix: nil, **options)
-          client.index(
-            index: index_name(suffix: suffix), type: type_name, id: id, body: body, **options
-          )
-        end
-        alias_method :index!, :index
-
-        # Updates a document using the specified script.
-        #
-        #   UsersIndex::User.update!(id: 1, body: { doc: { ... } }) # { '_id' => 1, ...}
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [Hash] :body the body of the request
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @raise [Elasticsearch::Transport::Transport::Errors::NotFound] when the doc does not exist
-        # @return [Hash] elasticsearch response hash
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-update.html
-        def update!(id:, body:, suffix: nil, **options)
-          client.update(
-            index: index_name(suffix: suffix), type: type_name, id: id, body: body, **options
-          )
-        end
-
-        # Updates a document using the specified script.
-        #
-        #   UsersIndex::User.update(id: 1, body: { doc: { ... } }) # { '_id' => 1, ...}
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [Hash] :body the body of the request
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @return [Hash] the elasticsearch response, or an hash with 'errors' as true in case of failure
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-update.html
-        def update(id:, body:, suffix: nil, **options)
-          update!(id: id, body: body, suffix: suffix, **options)
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound
-          { 'errors' => true }
-        end
-
-        # Removes a JSON document from the specified index.
-        #
-        #   UsersIndex::User.delete!(id: 1) # true
-        #   UsersIndex::User.delete!(id: 'missing') # raise Elasticsearch::Transport::Transport::Errors::NotFound
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @raise [Elasticsearch::Transport::Transport::Errors::NotFound] when the doc does not exist
-        # @return [Boolean] true when the operation is successfully completed
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-delete.html
-        def delete!(id:, suffix: nil, **options)
-          client.delete(options.merge(index: index_name(suffix: suffix), type: type_name, id: id))
-        end
-
-        # Removes a JSON document from the specified index.
-        #
-        #   UsersIndex::User.delete(id: 1) # true
-        #   UsersIndex::User.delete(id: 'missing') # false
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @raise [Elasticsearch::Transport::Transport::Errors::NotFound] when the doc does not exist
-        # @return [Boolean] true when the operation is successfully completed
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-delete.html
-        def delete(id:, suffix: nil, **options)
-          delete!(id: id, suffix: suffix, **options)
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound
-          false
-        end
-
-        # Gets the number of matches for a search query.
-        #
-        #   UsersIndex::User.count # 999
-        #   UsersIndex::User.count(body: { ... }) # 32
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [Hash] :body A query to restrict the results specified with the Query DSL (optional)
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @return [Integer] amount of documents found
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/search-count.html
-        def count(suffix: nil, **options)
-          response = client.count(options.merge(index: index_name(suffix: suffix), type: type_name))
-          response['count']
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound
-          0
-        end
-
-        # Check if a JSON document exists
-        #
-        #   UsersIndex::User.exist?(id: 1) # true
-        #   UsersIndex::User.exist?(id: 'missing') # false
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @return [Boolean] true if the document exists
-        def exist?(id:, suffix: nil, **options)
-          client.exists(options.merge(index: index_name(suffix: suffix), type: type_name, id: id))
-        end
-
-        # Retrieves the specified JSON document from an index.
-        #
-        #   UsersIndex::User.find!(id: 1) # { '_id' => 1, ... }
-        #   UsersIndex::User.find!(id: 'missing') # raise Elasticsearch::Transport::Transport::Errors::NotFound
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @raise [Elasticsearch::Transport::Transport::Errors::NotFound] when the doc does not exist
-        # @return [Hash] The elasticsearch document.
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-get.html
-        def find!(id:, suffix: nil, **options)
-          client.get(options.merge(index: index_name(suffix: suffix), type: type_name, id: id))
-        end
-
-        # Retrieves the specified JSON document from an index.
-        #
-        #   UsersIndex::User.find(id: 1) # { '_id' => 1, ... }
-        #   UsersIndex::User.find(id: 'missing') # nil
-        #
-        # @param options [Hash] Hash of paramenters that will be passed along to elasticsearch request
-        # @option [String, Integer] :id The `_id` of the elasticsearch document
-        # @option [String, nil] :suffix The index suffix. Defaults to the nil.
-        # @return [Hash, nil] The elasticsearch document
-        #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-get.html
-        def find(id:, suffix: nil, **options)
-          find!(id: id, suffix: suffix, **options)
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound
-          nil
-        end
-      end
-
-      include InstanceMethods
-    end
-  end
-end

data/lib/esse/backend/index_type.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Esse
-  module Backend
-    class IndexType
-      require_relative 'index_type/documents'
-
-      extend Forwardable
-
-      # Type delegators
-      def_delegators :@index_type, :type_name, :each_serialized_batch, :serialize
-
-      def initialize(type)
-        @index_type = type
-      end
-
-      protected
-
-      def index_name(suffix: nil)
-        suffix = Hstring.new(suffix).underscore.presence
-        return index_class.index_name unless suffix
-
-        [index_class.index_name, suffix].join('_')
-      end
-
-      def index_class
-        @index_type.index
-      end
-
-      def client
-        index_class.cluster.client
-      end
-    end
-  end
-end

data/lib/esse/cli/templates/type_mappings.json

@@ -1,6 +0,0 @@
-{
-  "name": {
-    "type": "string",
-    "index": "analyzed"
-  }
-}

data/lib/esse/cli/templates/type_serializer.rb.erb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-class <%= @index_name %> < <%= @base_class %>
-  module Serializers
-    class <%= @type.camelize %>Serializer
-      def initialize(<%= @type %>, **params)
-        @entity = <%= @type %>
-        @params = params
-      end
-
-      def to_h
-        {
-          id: entity.id, # This field is required
-          name: entity.name,
-        }
-      end
-
-      protected
-
-      attr_reader :entity, :params
-    end
-  end
-end

data/lib/esse/index/naming.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Esse
-  class Index
-    module ClassMethods
-      TEMPLATE_DIRS = [
-        '%<dirname>s/templates',
-        '%<dirname>s'
-      ].freeze
-
-      def index_name=(value)
-        @index_name = index_prefixed_name(value)
-      end
-
-      def index_name
-        @index_name || index_prefixed_name(normalized_name)
-      end
-
-      def index_name?
-        !index_name.nil?
-      end
-
-      def index_version=(value)
-        @index_version = Hstring.new(value.to_s).underscore.presence
-      end
-
-      def index_version
-        @index_version
-      end
-
-      def uname
-        Hstring.new(name).underscore.presence
-      end
-
-      def index_directory
-        return unless uname
-        return if uname == 'Esse::Index'
-
-        Esse.config.indices_directory.join(uname).to_s
-      end
-
-      def template_dirs
-        return [] unless index_directory
-
-        TEMPLATE_DIRS.map { |term| format(term, dirname: index_directory) }
-      end
-
-      protected
-
-      def index_prefixed_name(value)
-        return if value == '' || value.nil?
-        return value.to_s unless cluster.index_prefix
-
-        [cluster.index_prefix, value].join('_')
-      end
-
-      def normalized_name
-        Hstring.new(name).demodulize.underscore.sub(/_(index)$/, '')
-      end
-    end
-
-    extend ClassMethods
-  end
-end

data/lib/esse/index_type/mappings.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Esse
-  class IndexType
-    # https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-put-mapping.html
-    module ClassMethods
-      # This method is only used to define mapping
-      def mappings(hash = {}, &block)
-        @mapping = Esse::IndexMapping.new(body: hash, paths: template_dirs, filenames: mapping_filenames)
-        return unless block
-
-        @mapping.define_singleton_method(:to_h, &block)
-      end
-
-      # This is the actually content that will be passed through the ES api
-      def mappings_hash
-        hash = mapping.body
-        {
-          type_name => (hash.key?('properties') ? hash : { 'properties' => hash }),
-        }
-      end
-
-      private
-
-      def mapping
-        @mapping ||= Esse::IndexMapping.new(paths: template_dirs, filenames: mapping_filenames)
-      end
-
-      def template_dirs
-        return [] unless respond_to?(:index)
-
-        index.template_dirs
-      end
-
-      def mapping_filenames
-        Esse::IndexMapping::FILENAMES.map { |str| [type_name, str].join('_') }
-      end
-    end
-
-    extend ClassMethods
-  end
-end

data/lib/esse/index_type.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'object_document_mapper'
-
-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 IndexType
-    require_relative 'index_type/actions'
-    require_relative 'index_type/mappings'
-    require_relative 'index_type/backend'
-    extend ObjectDocumentMapper
-  end
-end

data/lib/esse/object_document_mapper.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Esse
-  module ObjectDocumentMapper
-    # 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 block
-        @serializer_proc = block
-      elsif klass.is_a?(Class) && klass.instance_methods.include?(:to_h)
-        @serializer_proc = proc { |*args, **kwargs| klass.new(*args, **kwargs).to_h }
-      elsif klass.is_a?(Class) && klass.instance_methods.include?(:as_json) # backward compatibility
-        @serializer_proc = proc { |*args, **kwargs| klass.new(*args, **kwargs).as_json }
-      elsif klass.is_a?(Class) && klass.instance_methods.include?(:call)
-        @serializer_proc = proc { |*args, **kwargs| klass.new(*args, **kwargs).call }
-      else
-        msg = format('%<arg>p is not a valid serializer. The serializer should ' \
-                      'respond with `to_h` instance method.', arg: klass,)
-        raise ArgumentError, msg
-      end
-    end
-
-    def serialize(model, *args, **kwargs)
-      unless @serializer_proc
-        raise NotImplementedError, format('there is no serializer defined for the %<k>p index', k: to_s)
-      end
-
-      @serializer_proc.call(model, *args, **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.
-    #
-    # Here is an example of how this should work:
-    #   collection do |conditions, &block|
-    #     User.where(conditions).find_in_batches(batch_size: 5000) do |batch|
-    #       block.call(batch, conditions)
-    #     end
-    #   end
-    def collection(collection_class = nil, &block)
-      raise ArgumentError, 'a collection class or a block is required' if block.nil? && collection_class.nil?
-
-      if block.nil? && collection_class.is_a?(Class) && !collection_class.include?(Enumerable)
-        msg = '%<arg>p is not a valid collection class.' \
-              ' Collections should implement the Enumerable interface'
-        raise ArgumentError, format(msg, arg: collection_class)
-      end
-
-      @collection_proc = collection_class || 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, _opts|
-    #     puts data.size
-    #   end
-    def each_batch(*args, **kwargs, &block)
-      unless @collection_proc
-        raise NotImplementedError, format('there is no collection defined for the %<k>p index', k: 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 args [*Object] Any argument is allowed here. The collection will be called with same arguments.
-    #   And the serializer will be initialized with those arguments too.
-    # @yield [Array, *Object] serialized collection and method arguments
-    def each_serialized_batch(**kwargs, &block)
-      each_batch(**kwargs) do |*batch, **collection_kwargs|
-        entries = batch.flatten.map { |entry| serialize(entry, **collection_kwargs) }.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 |documents, **_collection_kargs|
-          documents.each { |document| yielder.yield(document) }
-        end
-      end
-    end
-  end
-end