esse 0.2.2 → 0.2.4

data/lib/esse/deprecations/deprecate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Esse
+  module Deprecations
+    module Deprecate
+      def self.extended(base)
+        base.extend Gem::Deprecate
+        base.include InstanceMethods
+      end
+
+      module InstanceMethods
+        def warning(method, repl, year, month)
+          msg = ["NOTE: #{method} is deprecated"]
+          msg << if repl == :none
+            ' with no replacement'
+          elsif repl.respond_to?(:call)
+            "; use #{repl.call} instead"
+          else
+            "; use #{repl} instead"
+          end
+          msg << '. It will be removed on or after %4d-%02d-01.' % [year, month]
+          msg << "\n#{method} called from #{Gem.location_of_caller(2).join(':')}"
+
+          warn "#{msg.join}." unless Gem::Deprecate.skip
+        end
+      end
+    end
+  end
+end

data/lib/esse/deprecations/index.rb

@@ -3,17 +3,35 @@
 module Esse
   class Index
     class << self
-      extend Gem::Deprecate
+      extend Esse::Deprecations::Deprecate
 
       def define_type(name, *args, **kwargs, &block)
         repository(name, *args, **kwargs, &block)
       end
-      deprecate :define_type, :repository, 2022, 8
+      deprecate :define_type, :repository, 2023, 12
 
       def type_hash
         repo_hash
       end
-      deprecate :type_hash, :repo_hash, 2022, 8
+      deprecate :type_hash, :repo_hash, 2023, 12
+
+      def index_version
+        index_suffix
+      end
+      deprecate :index_version, :index_suffix, 2023, 12
+
+      def index_version=(value)
+        self.index_suffix = value
+      end
+      deprecate :index_version=, :index_suffix=, 2023, 12
+
+      def elasticsearch
+        Esse::Deprecations::IndexBackendDelegator.new(:elasticsearch, self)
+      end
+
+      def backend
+        Esse::Deprecations::IndexBackendDelegator.new(:backend, self)
+      end
     end
   end
 end

data/lib/esse/deprecations/index_backend_delegator.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Esse
+  module Deprecations
+    class IndexBackendDelegator
+      extend Esse::Deprecations::Deprecate
+
+      def initialize(namespace, index)
+        @namespace = namespace
+        @index = index
+      end
+
+      def aliases(**kwargs)
+        warning("#{@index}.#{@namespace}.aliases", "#{@index}.aliases", 2023, 12)
+        @index.aliases(**kwargs)
+      end
+
+      def indices(**kwargs)
+        warning("#{@index}.#{@namespace}.indices", "#{@index}.indices_pointing_to_alias", 2023, 12)
+        @index.indices_pointing_to_alias(**kwargs)
+      end
+
+      def update_aliases!(**kwargs)
+        warning("#{@index}.#{@namespace}.update_aliases!", "#{@index}.update_aliases", 2023, 12)
+        @index.update_aliases(**kwargs)
+      end
+
+      def update_aliases(**kwargs)
+        warning("#{@index}.#{@namespace}.update_aliases", "#{@index}.update_aliases", 2023, 12)
+
+        @index.update_aliases(**kwargs)
+      rescue Esse::Transport::NotFoundError
+        { 'errors' => true }
+      end
+
+      def create_index(**kwargs)
+        warning("#{@index}.#{@namespace}.create_index", "#{@index}.create_index", 2023, 12)
+
+        @index.create_index(**kwargs)
+      end
+
+      def create_index!(**kwargs)
+        warning("#{@index}.#{@namespace}.create_index!", "#{@index}.create_index", 2023, 12)
+
+        @index.create_index(**kwargs)
+      end
+
+      def close(**kwargs)
+        warning("#{@index}.#{@namespace}.close", "#{@index}.close", 2023, 12)
+
+        @index.close(**kwargs)
+      end
+
+      def close!(**kwargs)
+        warning("#{@index}.#{@namespace}.close!", "#{@index}.close", 2023, 12)
+
+        @index.close(**kwargs)
+      end
+
+      def open(**kwargs)
+        warning("#{@index}.#{@namespace}.open", "#{@index}.open", 2023, 12)
+
+        @index.open(**kwargs)
+      end
+
+      def open!(**kwargs)
+        warning("#{@index}.#{@namespace}.open!", "#{@index}.open", 2023, 12)
+
+        @index.open(**kwargs)
+      end
+
+      def refresh(**kwargs)
+        warning("#{@index}.#{@namespace}.refresh", "#{@index}.refresh", 2023, 12)
+
+        @index.refresh(**kwargs)
+      end
+
+      def refresh!(**kwargs)
+        warning("#{@index}.#{@namespace}.refresh!", "#{@index}.refresh", 2023, 12)
+
+        @index.refresh(**kwargs)
+      end
+
+      def delete_index(**kwargs)
+        warning("#{@index}.#{@namespace}.delete_index", "#{@index}.delete_index", 2023, 12)
+
+        @index.delete_index(**kwargs)
+      end
+
+      def delete_index!(**kwargs)
+        warning("#{@index}.#{@namespace}.delete_index!", "#{@index}.delete_index", 2023, 12)
+
+        @index.delete_index(**kwargs)
+      end
+
+      def index_exist?(**kwargs)
+        warning("#{@index}.#{@namespace}.index_exist?", "#{@index}.index_exist?", 2023, 12)
+
+        @index.index_exist?(**kwargs)
+      end
+
+      def update_mapping!(**kwargs)
+        warning("#{@index}.#{@namespace}.update_mapping!", "#{@index}.update_mapping", 2023, 12)
+
+        @index.update_mapping(**kwargs)
+      end
+
+      def update_mapping(**kwargs)
+        warning("#{@index}.#{@namespace}.update_mapping", "#{@index}.update_mapping", 2023, 12)
+
+        @index.update_mapping(**kwargs)
+      end
+
+      def update_settings!(**kwargs)
+        warning("#{@index}.#{@namespace}.update_settings!", "#{@index}.update_settings", 2023, 12)
+
+        @index.update_settings(**kwargs)
+      end
+
+      def update_settings(**kwargs)
+        warning("#{@index}.#{@namespace}.update_settings", "#{@index}.update_settings", 2023, 12)
+
+        @index.update_settings(**kwargs)
+      end
+
+      def reset_index!(**kwargs)
+        warning("#{@index}.#{@namespace}.reset_index!", "#{@index}.reset_index", 2023, 12)
+
+        @index.reset_index(**kwargs)
+      end
+
+      def import(**kwargs)
+        warning("#{@index}.#{@namespace}.import", "#{@index}.import", 2023, 12)
+
+        @index.import(**kwargs)
+      end
+
+      def import!(**kwargs)
+        warning("#{@index}.#{@namespace}.import!", "#{@index}.import", 2023, 12)
+
+        @index.import(**kwargs)
+      end
+
+      def bulk!(**kwargs)
+        warning("#{@index}.#{@namespace}.bulk!", "#{@index}.bulk", 2023, 12)
+
+        @index.bulk(**kwargs)
+      end
+
+      def bulk(**kwargs)
+        warning("#{@index}.#{@namespace}.bulk", "#{@index}.bulk", 2023, 12)
+
+        @index.bulk(**kwargs)
+      end
+
+      def index!(**kwargs)
+        warning("#{@index}.#{@namespace}.index!", "#{@index}.index", 2023, 12)
+
+        @index.index(**kwargs)
+      end
+
+      def index(**kwargs)
+        warning("#{@index}.#{@namespace}.index", "#{@index}.index", 2023, 12)
+
+        @index.index(**kwargs)
+      end
+
+      def update!(**kwargs)
+        warning("#{@index}.#{@namespace}.update!", "#{@index}.update", 2023, 12)
+
+        @index.update(**kwargs)
+      end
+
+      def update(**kwargs)
+        warning("#{@index}.#{@namespace}.update", "#{@index}.update", 2023, 12)
+
+        @index.update(**kwargs)
+      end
+
+      def delete!(**kwargs)
+        warning("#{@index}.#{@namespace}.delete!", "#{@index}.delete", 2023, 12)
+
+        @index.delete(**kwargs)
+      end
+
+      def delete(**kwargs)
+        warning("#{@index}.#{@namespace}.delete", "#{@index}.delete", 2023, 12)
+
+        @index.delete(**kwargs)
+      end
+
+      def count(**kwargs)
+        warning("#{@index}.#{@namespace}.count", "#{@index}.count", 2023, 12)
+
+        @index.count(**kwargs)
+      end
+
+      def exist?(**kwargs)
+        warning("#{@index}.#{@namespace}.exist?", "#{@index}.exist?", 2023, 12)
+
+        @index.exist?(**kwargs)
+      end
+
+      def find!(**kwargs)
+        warning("#{@index}.#{@namespace}.find!", "#{@index}.get", 2023, 12)
+
+        @index.get(**kwargs)
+      end
+
+      def find(**kwargs)
+        warning("#{@index}.#{@namespace}.find", "#{@index}.get", 2023, 12)
+
+        @index.get(**kwargs)
+      end
+    end
+  end
+end

data/lib/esse/deprecations/repository.rb

@@ -3,17 +3,32 @@
 module Esse
   class Repository
     class << self
-      extend Gem::Deprecate
+      extend Esse::Deprecations::Deprecate
 
       def type_name
-        document_type
+        repo_name
       end
-      deprecate :type_name, :document_type, 2022, 10
+      deprecate :type_name, :repo_type, 2023, 12
 
       def mappings(*args, &block)
+        warning("#{self}.mappings", "#{index}.mappings", 2023, 12)
+
         index.mappings(*args, &block)
       end
-      deprecate :mappings, "Esse::Index.mappings", 2022, 10
+
+      def serializer(*args, **kwargs, &block)
+        warning("#{self}.serializer", "#{self}.document", 2023, 12)
+
+        document(*args, **kwargs, &block)
+      end
+
+      def elasticsearch
+        Esse::Deprecations::RepositoryBackendDelegator.new(:elasticsearch, self)
+      end
+
+      def backend
+        Esse::Deprecations::RepositoryBackendDelegator.new(:backend, self)
+      end
     end
   end
 end

data/lib/esse/deprecations/repository_backend_delegator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Esse
+  module Deprecations
+    class RepositoryBackendDelegator
+      extend Esse::Deprecations::Deprecate
+
+      def initialize(namespace, repo)
+        @namespace = namespace
+        @repo = repo
+      end
+
+      def import(**kwargs)
+        warning("#{@repo}.#{@namespace}.import", "#{@repo}.import", 2023, 12)
+
+        @repo.import(**kwargs)
+      end
+
+      def import!(**kwargs)
+        warning("#{@repo}.#{@namespace}.import!", "#{@repo}.import", 2023, 12)
+
+        @repo.import(**kwargs)
+      end
+
+      def bulk(**kwargs)
+        warning("#{@repo}.#{@namespace}.bulk", "#{@repo.index}.bulk", 2023, 12)
+
+        @repo.index.bulk(**kwargs)
+      end
+
+      def bulk!(**kwargs)
+        warning("#{@repo}.#{@namespace}.bulk!", "#{@repo.index}.bulk", 2023, 12)
+
+        @repo.index.bulk(**kwargs)
+      end
+
+      def index(**kwargs)
+        warning("#{@repo}.#{@namespace}.index", "#{@repo.index}.index", 2023, 12)
+
+        @repo.index.index(**kwargs)
+      end
+
+      def index!(**kwargs)
+        warning("#{@repo}.#{@namespace}.index!", "#{@repo.index}.index", 2023, 12)
+
+        @repo.index.index(**kwargs)
+      end
+
+      def index_document(*args, **kwargs)
+        warning("#{@repo}.#{@namespace}.index_document", "#{@repo.index}.index", 2023, 12)
+
+        @repo.index.index(*args, **kwargs)
+      end
+
+      def update!(**kwargs)
+        warning("#{@repo}.#{@namespace}.update!", "#{@repo.index}.update", 2023, 12)
+
+        @repo.index.update(**kwargs)
+      end
+
+      def update(**kwargs)
+        warning("#{@repo}.#{@namespace}.update", "#{@repo.index}.update", 2023, 12)
+
+        @repo.index.update(**kwargs)
+      end
+
+      def delete!(**kwargs)
+        warning("#{@repo}.#{@namespace}.delete!", "#{@repo.index}.delete", 2023, 12)
+
+        @repo.index.delete(**kwargs)
+      end
+
+      def delete(**kwargs)
+        warning("#{@repo}.#{@namespace}.delete", "#{@repo.index}.delete", 2023, 12)
+
+        @repo.index.delete(**kwargs)
+      end
+
+      def delete_document(*args, **kwargs)
+        warning("#{@repo}.#{@namespace}.delete_document", "#{@repo.index}.delete", 2023, 12)
+
+        @repo.index.delete(*args, **kwargs)
+      end
+
+      def count(**kwargs)
+        warning("#{@repo}.#{@namespace}.count", "#{@repo.index}.count", 2023, 12)
+
+        @repo.index.count(**kwargs)
+      end
+
+      def exist?(**kwargs)
+        warning("#{@repo}.#{@namespace}.exist?", "#{@repo.index}.exist?", 2023, 12)
+
+        @repo.index.exist?(**kwargs)
+      end
+
+      def find!(**kwargs)
+        warning("#{@repo}.#{@namespace}.find!", "#{@repo.index}.get", 2023, 12)
+
+        @repo.index.get(**kwargs)
+      end
+
+      def find(**kwargs)
+        warning("#{@repo}.#{@namespace}.find", "#{@repo.index}.get", 2023, 12)
+
+        @repo.index.get(**kwargs)
+      end
+    end
+  end
+end

data/lib/esse/deprecations/serializer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Esse
+  class Serializer < Esse::Document
+    class << self
+      extend Esse::Deprecations::Deprecate
+
+      def inherited(subclass)
+        warning 'Esse::Serializer', 'Esse::Document', 2023, 12
+        super(subclass)
+      end
+    end
+  end
+end

data/lib/esse/deprecations.rb

@@ -1,3 +1,7 @@
+require_relative 'deprecations/deprecate'
+require_relative 'deprecations/serializer'
+require_relative 'deprecations/index_backend_delegator'
 require_relative 'deprecations/index'
 require_relative 'deprecations/cluster'
+require_relative 'deprecations/repository_backend_delegator'
 require_relative 'deprecations/repository'

data/lib/esse/{serializer.rb → document.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Esse
-  class Serializer
+  class Document
     attr_reader :object, :options
 
     def initialize(object, **options)
@@ -21,12 +21,27 @@ module Esse
       nil
     end
 
+    # @return [Boolean] whether the document has type
+    def type?
+      !type.nil?
+    end
+
     # @return [String, nil] the document routing
     # @abstract Override this method to return the document routing
     def routing
       nil
     end
 
+    # @return [Boolean] whether the document has routing
+    def routing?
+      !routing.nil?
+    end
+
+    # @TODO allow import, index, bulk to accept a suffix to tell which index to use
+    # def index_suffix
+    #   nil
+    # end
+
     # @return [Hash] the document meta
     # @abstract Override this method to return the document meta
     def meta
@@ -54,7 +69,7 @@ module Esse
       { _id: id }.tap do |h|
         h[:data] = source&.to_h if data
         h[:_type] = type if type
-        h[:routing] = routing if routing
+        h[:routing] = routing if routing?
         h.merge!(meta)
       end
     end

data/lib/esse/dynamic_template.rb

@@ -11,6 +11,10 @@ module Esse
       @hash = HashUtils.deep_merge(@hash, normalize(value))
     end
 
+    def []=(key, value)
+      merge!(key => value)
+    end
+
     def to_a
       @hash.map do |name, value|
         { name => value }

data/lib/esse/errors.rb

@@ -5,9 +5,16 @@ module Esse
   end
 
   # @todo Rename this
-  module Backend
+  class Transport
     class ServerError < ::Esse::Error; end
 
+    # exception to raise when the cluster is readonly
+    class ReadonlyClusterError < ::Esse::Error
+      def initialize
+        super('You cannot perform this operation on a readonly cluster')
+      end
+    end
+
     ES_TRANSPORT_ERRORS = {
       'MultipleChoices' => 'MultipleChoicesError', # 300
       'MovedPermanently' => 'MovedPermanentlyError', # 301

data/lib/esse/events.rb

@@ -38,15 +38,23 @@ module Esse
   module Events
     include Publisher
 
+    register_event 'elasticsearch.bulk'
     register_event 'elasticsearch.close'
-    register_event 'elasticsearch.open'
     register_event 'elasticsearch.create_index'
     register_event 'elasticsearch.delete_index'
+    register_event 'elasticsearch.execute_search_query'
+    register_event 'elasticsearch.index_exist'
+    register_event 'elasticsearch.open'
+    register_event 'elasticsearch.refresh'
+    register_event 'elasticsearch.search'
+    register_event 'elasticsearch.update_aliases'
     register_event 'elasticsearch.update_mapping'
     register_event 'elasticsearch.update_settings'
-    register_event 'elasticsearch.update_aliases'
-    register_event 'elasticsearch.bulk'
-    register_event 'elasticsearch.search'
-    register_event 'elasticsearch.execute_search_query'
+    register_event 'elasticsearch.index'
+    register_event 'elasticsearch.update'
+    register_event 'elasticsearch.delete'
+    register_event 'elasticsearch.exist'
+    register_event 'elasticsearch.count'
+    register_event 'elasticsearch.get'
   end
 end

data/lib/esse/hash_document.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Esse
-  class HashDocument < Esse::Serializer
+  class HashDocument < Esse::Document
     META_KEYS = %i[_id _type _routing routing].freeze
 
     def initialize(object)

data/lib/esse/import/bulk.rb

@@ -1,15 +1,21 @@
 module Esse
   module Import
     class Bulk
-      def initialize(index: nil, delete: nil, create: nil)
+      def initialize(type: nil, index: nil, delete: nil, create: nil)
         @index = Array(index).select(&method(:valid_doc?)).reject(&:ignore_on_index?).map do |doc|
-          { index: doc.to_bulk }
+          value = doc.to_bulk
+          value[:_type] ||= type if type
+          { index: value }
         end
         @create = Array(create).select(&method(:valid_doc?)).reject(&:ignore_on_index?).map do |doc|
-          { create: doc.to_bulk }
+          value = doc.to_bulk
+          value[:_type] ||= type if type
+          { create: value }
         end
         @delete = Array(delete).select(&method(:valid_doc?)).reject(&:ignore_on_delete?).map do |doc|
-          { delete: doc.to_bulk(data: false) }
+          value = doc.to_bulk(data: false)
+          value[:_type] ||= type if type
+          { delete: value }
         end
       end
 
@@ -22,26 +28,31 @@ module Esse
       #
       # @yield [RequestBody] A request body instance
       def each_request(max_retries: 3)
+        # @TODO create indexes when by checking all the index suffixes (if mapping is not empty)
         requests = [optimistic_request]
         retry_count = 0
 
         begin
           requests.each do |request|
-            yield(request) if request.body?
+            next unless request.body?
+            resp = yield request
+            if resp&.[]('errors')
+              raise resp&.fetch('items', [])&.select { |item| item.values.first['error'] }&.join("\n")
+            end
           end
-        rescue Faraday::TimeoutError, Esse::Backend::RequestTimeoutError => e
+        rescue Faraday::TimeoutError, Esse::Transport::RequestTimeoutError => e
           retry_count += 1
-          raise Esse::Backend::RequestTimeoutError.new(e.message) if retry_count >= max_retries
+          raise Esse::Transport::RequestTimeoutError.new(e.message) if retry_count >= max_retries
           wait_interval = (retry_count**4) + 15 + (rand(10) * (retry_count + 1))
           Esse.logger.warn "Timeout error, retrying in #{wait_interval} seconds"
           sleep(wait_interval)
           retry
-        rescue Esse::Backend::RequestEntityTooLargeError => e
+        rescue Esse::Transport::RequestEntityTooLargeError => e
           retry_count += 1
           raise e if retry_count > 1 # only retry once on this error
           requests = balance_requests_size(e)
           Esse.logger.warn <<~MSG
-            Request entity too large, retrying with a bulk with: #{requests.map(&:bytesize).join(" + ")}.
+            Request entity too large, retrying with a bulk with: #{requests.map(&:bytesize).join(' + ')}.
             Note that this cause performance degradation, consider adjusting the batch_size of the index or increasing the bulk size.
           MSG
           retry
@@ -51,7 +62,7 @@ module Esse
       private
 
       def valid_doc?(doc)
-        doc && doc.is_a?(Esse::Serializer) && doc.id
+        Esse.document?(doc)
       end
 
       def optimistic_request
@@ -90,7 +101,6 @@ module Esse
           raise err
         end
       end
-
     end
   end
 end