esse 0.2.2 → 0.2.3

data/lib/esse/index/attributes.rb

@@ -31,17 +31,20 @@ module Esse
       end
 
       def index_prefix=(value)
-        return @index_prefix = nil if value == false
+        if value == false
+          @index_prefix = nil
+          return
+        end
 
         @index_prefix = Hstring.new(value.to_s).underscore.presence
       end
 
-      def index_version=(value)
-        @index_version = Hstring.new(value.to_s).underscore.presence
+      def index_suffix=(value)
+        @index_suffix = Hstring.new(value.to_s).underscore.presence
       end
 
-      def index_version
-        @index_version
+      def index_suffix
+        @index_suffix
       end
 
       def uname
@@ -91,6 +94,12 @@ module Esse
       def normalized_name
         Hstring.new(name).underscore.tr('/', '_').sub(/_(index)$/, '')
       end
+
+      def build_real_index_name(suffix = nil)
+        suffix = Hstring.new(suffix).underscore.presence || index_suffix || Esse.timestamp
+
+        index_name(suffix: suffix)
+      end
     end
 
     extend ClassMethods

data/lib/esse/index/base.rb

@@ -3,48 +3,23 @@
 module Esse
   class Index
     module ClassMethods
-      # Define a Index method on the given module that calls the Index
-      # method on the receiver. This is how the Esse::Index() method is
-      # defined, and allows you to define Index() methods on other modules,
-      # making it easier to have custom index settings for all indices under
-      # a namespace.  Example:
-      #
-      #   module V1
-      #     EsIndex = Class.new(Esse::Index)
-      #     EsIndex.def_Index(self)
-      #
-      #     class Bar < EsIndex
-      #       # Uses :default elasticsearch client connection
-      #     end
-      #
-      #     class Baz < EsIndex(:v1)
-      #       # Uses :v1 elasticsearch client connection
-      #     end
-      #   end
-      def def_Index(index_module) # rubocop:disable Naming/MethodName
-        tap do |model|
-          index_module.define_singleton_method(:Index) do |source|
-            model.Index(source)
-          end
+      # Sets the client_id associated with the Index class.
+      # This can be used directly on Esse::Index to set the :default es cluster
+      # to be used by subclasses, or to override the es client used for specific indices:
+      #   Esse::Index.cluster_id = :v1
+      #   ArtistIndex = Class.new(Esse::Index)
+      #   ArtistIndex.cluster_id = :v2
+      # @param [Symbol, Esse::Cluster, NilClass] source the cluster id or the cluster instance
+      # @return [Symbol] the cluster id
+      # @raise [ArgumentError] if the cluster id is not defined in the Esse.config
+      def cluster_id=(source)
+        if source.nil?
+          @cluster_id = nil
+          return
         end
-      end
-
-      # Lets you create a Index subclass with its elasticsearch cluster
-      #
-      # Example:
-      #   # Using a custom cluster
-      #   Esse.config.cluster(:v1).client = Elasticsearch::Client.new
-      #   class UsersIndex < Esse::Index(:v1)
-      #   end
-      #
-      #   # Using :default cluster
-      #   class UsersIndex < Esse::Index
-      #   end
-      def Index(source) # rubocop:disable Naming/MethodName
-        klass = Class.new(self)
 
         valid_ids = Esse.config.cluster_ids
-        klass.cluster_id = \
+        new_id = \
           case source
           when Esse::Cluster
             source.id
@@ -55,7 +30,7 @@ module Esse
 
         msg = <<~MSG
           We could not resolve the index cluster using the argument %<arg>p. \n
-          It must be previously defined in the `Esse.config' settings. \n
+          It must be previously defined in the `Esse.config.cluster(%<arg>p) { ... }' settings. \n
           Here is the list of cluster ids we have configured: %<ids>s\n
 
           You can ignore this cluster id entirely. That way the :default id will be used.\n
@@ -63,22 +38,11 @@ module Esse
             class UsersIndex < Esse::Index\n
             end\n
         MSG
-        unless klass.cluster_id
+        unless new_id
           raise ArgumentError.new, format(msg, arg: source, ids: valid_ids.map(&:inspect).join(', '))
         end
 
-        klass.repo_hash = {}
-        klass
-      end
-
-      # Sets the client_id associated with the Index class.
-      # This can be used directly on Esse::Index to set the :default es cluster
-      # to be used by subclasses, or to override the es client used for specific indices:
-      #   Esse::Index.cluster_id = :v1
-      #   ArtistIndex = Class.new(Esse::Index)
-      #   ArtistIndex.cluster_id = :v2
-      def cluster_id=(cluster_id)
-        @cluster_id = cluster_id
+        @cluster_id = new_id
       end
 
       # @return [Symbol] reads the @cluster_id instance variable or :default

data/lib/esse/index/documents.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      # Retrieves the specified JSON document from an index.
+      #
+      #   UsersIndex.get(id: 1) # { '_id' => 1, ... }
+      #   UsersIndex.get(id: 'missing') # raise Esse::Transport::NotFoundError
+      #
+      # @param doc [Esse::Document] the document to retrieve
+      # @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, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @option [String, nil] :suffix The index suffix. Defaults to the nil.
+      # @raise [Esse::Transport::NotFoundError] 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 get(doc = nil, suffix: nil, **options)
+        if document?(doc)
+          options[:id] = doc.id
+          options[:type] = doc.type if doc.type?
+          options[:routing] = doc.routing if doc.routing?
+        end
+        require_kwargs!(options, :id)
+        options[:index] = index_name(suffix: suffix)
+        cluster.may_update_type!(options)
+        cluster.api.get(**options)
+      end
+
+      # Check if a JSON document exists
+      #
+      #   UsersIndex.exist?(id: 1) # true
+      #   UsersIndex.exist?(id: 'missing') # false
+      #
+      # @param doc [Esse::Document] the document to retrieve
+      # @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, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @option [String, nil] :suffix The index suffix. Defaults to the nil.
+      # @return [Boolean] true if the document exists
+      def exist?(doc = nil, suffix: nil, **options)
+        if document?(doc)
+          options[:id] = doc.id
+          options[:type] = doc.type if doc.type?
+          options[:routing] = doc.routing if doc.routing?
+        end
+        require_kwargs!(options, :id)
+        options[:index] = index_name(suffix: suffix)
+        cluster.may_update_type!(options)
+        cluster.api.exist?(**options)
+      end
+
+      # Gets the number of matches for a search query.
+      #
+      #   UsersIndex.count # 999
+      #   UsersIndex.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, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @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(type: nil, suffix: nil, **options)
+        params = {
+          index: index_name(suffix: suffix),
+          type: type,
+        }
+        cluster.may_update_type!(params)
+        cluster.api.count(**options, **params)['count']
+      end
+
+      # Removes a JSON document from the specified index.
+      #
+      #   UsersIndex.delete(id: 1) # true
+      #   UsersIndex.delete(id: 'missing') # false
+      #
+      # @param doc [Esse::Document] the document to retrieve
+      # @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, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @option [String, nil] :suffix The index suffix. Defaults to the nil.
+      # @raise [Esse::Transport::NotFoundError] when the doc does not exist
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-delete.html
+      def delete(doc = nil, suffix: nil, **options)
+        if document?(doc)
+          options[:id] = doc.id
+          options[:type] = doc.type if doc.type?
+          options[:routing] = doc.routing if doc.routing?
+        end
+        require_kwargs!(options, :id)
+        options[:index] = index_name(suffix: suffix)
+        cluster.may_update_type!(options)
+        cluster.api.delete(**options)
+      end
+
+      # Updates a document using the specified script.
+      #
+      #   UsersIndex.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, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @option [String, nil] :suffix The index suffix. Defaults to the nil.
+      # @raise [Esse::Transport::NotFoundError] 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(doc = nil, suffix: nil, **options)
+        if document?(doc)
+          options[:id] = doc.id
+          options[:body] = { doc: doc.source }
+          options[:type] = doc.type if doc.type?
+          options[:routing] = doc.routing if doc.routing?
+        end
+        require_kwargs!(options, :id, :body)
+        options[:index] = index_name(suffix: suffix)
+        cluster.may_update_type!(options)
+        cluster.api.update(**options)
+      end
+
+      # 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, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @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(doc = nil, suffix: nil, **options)
+        if document?(doc)
+          options[:id] = doc.id
+          options[:body] = doc.source
+          options[:type] = doc.type if doc.type?
+          options[:routing] = doc.routing if doc.routing?
+        end
+        require_kwargs!(options, :id, :body)
+        options[:index] = index_name(suffix: suffix)
+        cluster.may_update_type!(options)
+        cluster.api.index(**options)
+      end
+
+      # 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<Esse::Document>] :index list of documents to be indexed(Optional)
+      # @option [Array<Esse::Document>] :delete list of documents to be deleted(Optional)
+      # @option [Array<Esse::Document>] :create list of documents to be created(Optional)
+      # @option [String, NilClass] :type The type of the document (Optional for elasticsearch >= 7)
+      # @return [Array<Esse::Import::RequestBody>] The list of request bodies. @TODO Change this to a Stats object
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docs-bulk.html
+      # @see https://github.com/elastic/elasticsearch-ruby/blob/main/elasticsearch-api/lib/elasticsearch/api/utils.rb
+      # @see https://github.com/elastic/elasticsearch-ruby/blob/main/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
+      def bulk(index: nil, delete: nil, create: nil, type: nil, suffix: nil, **options)
+        definition = {
+          index: index_name(suffix: suffix),
+          type: type,
+        }.merge(options)
+        cluster.may_update_type!(definition)
+
+        # @TODO Wrap the return in a some other Stats object with more information
+        Esse::Import::Bulk.new(
+          **definition.slice(:type),
+          index: index,
+          delete: delete,
+          create: create,
+        ).each_request do |request_body|
+          cluster.api.bulk(**definition, body: request_body.body) do |event_payload|
+            event_payload[:body_stats] = request_body.stats
+            if bulk_wait_interval > 0
+              event_payload[:wait_interval] = bulk_wait_interval
+              sleep(bulk_wait_interval)
+            else
+              event_payload[:wait_interval] = 0.0
+            end
+          end
+        end
+      end
+
+      # Resolve collection and index data
+      #
+      # @param repos [Array<String>] List of repo types. Defaults to all types.
+      # @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.
+      # @return [Numeric] The number of documents imported
+      def import(*repo_types, context: {}, suffix: nil, **options)
+        repo_types = repo_hash.keys if repo_types.empty?
+        count = 0
+        repo_hash.slice(*repo_types).each do |repo_name, repo|
+          repo.each_serialized_batch(**(context || {})) do |batch|
+            # Elasticsearch 6.x and older have multiple types per index.
+            # This gem supports multiple types per index for backward compatibility, but we recommend to update
+            # your elasticsearch to a at least 7.x version and use a single type per index.
+            #
+            # Note that the repository name will be used as the document type.
+            # mapping_default_type
+            kwargs = { index: batch, suffix: suffix, type: repo_name, **options }
+            cluster.may_update_type!(kwargs)
+            bulk(**kwargs)
+            count += batch.size
+          end
+        end
+        count
+      end
+
+      protected
+
+      def document?(doc)
+        Esse.document?(doc)
+      end
+
+      def require_kwargs!(options, *keys)
+        keys.each do |key|
+          raise ArgumentError, "missing keyword: #{key}" unless options.key?(key)
+        end
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/indices.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Esse
+  class Index
+    module ClassMethods
+      CREATE_INDEX_RESERVED_KEYWORDS = {
+        alias: true,
+      }.freeze
+
+      # Creates index and applies mappings and settings.
+      #
+      #   UsersIndex.create_index # creates index named `<cluster.index_prefix>users<index_suffix>`
+      #
+      # @param options [Hash] Options hash
+      # @option options [Boolean] :alias Update `index_name` alias along with the new index
+      # @option options [String] :suffix The index suffix. Defaults to the `IndexClass#index_suffix` or
+      #   `Esse.timestamp`. Suffixed index names might be used for zero-downtime mapping change.
+      # @option arguments [String] :wait_for_active_shards Set the number of active shards
+      #    to wait for before the operation returns.
+      # @option arguments [Time] :timeout Explicit operation timeout
+      # @option arguments [Time] :master_timeout Specify timeout for connection to master
+      # @option arguments [Hash] :headers Custom HTTP headers
+      # @option arguments [Hash] :body The configuration for the index (`settings` and `mappings`)
+      # @raise [Esse::Transport::NotFoundError] when index already exists
+      # @return [Hash] the elasticsearch response
+      #
+      # @see http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/
+      # @see Esse::Transport#create_index
+      def create_index(suffix: nil, **options)
+        options = CREATE_INDEX_RESERVED_KEYWORDS.merge(options)
+        name = build_real_index_name(suffix)
+        definition = [settings_hash, mappings_hash].reduce(&:merge)
+
+        if options.delete(:alias) && name != index_name
+          definition[:aliases] = { index_name => {} }
+        end
+
+        cluster.api.create_index(index: name, body: definition, **options)
+      end
+
+      # Deletes, creates and imports data to the index. Performs zero-downtime index resetting.
+      #
+      # @option options [String, nil] :suffix The index suffix. Defaults to the index_suffix.
+      #   A uniq index name will be generated if one index already exist with the given alias.
+      # @option options [Time] :timeout Explicit operation timeout
+      # @raise [Esse::Transport::ServerError]
+      #   in case of failure
+      # @return [Hash] the elasticsearch response
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-open-close.html
+      def reset_index(suffix: index_suffix, import: true, reindex: false, **options)
+        cluster.throw_error_when_readonly!
+        existing = []
+        suffix ||= Esse.timestamp
+        suffix = Esse.timestamp while index_exist?(suffix: suffix).tap { |exist| existing << suffix if exist }
+
+        create_index(**options, suffix: suffix, alias: false)
+        if index_exist? && aliases.none?
+          cluster.api.delete_index(index: index_name)
+        end
+        if import
+          import(**options, suffix: suffix)
+        elsif reindex && (_from = indices_pointing_to_alias).any?
+          # @TODO: Reindex using the reindex API
+        end
+        update_aliases(suffix: suffix)
+        existing.each { |_s| delete_index!(**options, suffix: suffix) }
+        true
+      end
+
+      # Checks the index existance. Returns true or false
+      #
+      #   UsersIndex.index_exist? #=> true
+      #
+      # @param options [Hash] Options hash
+      # @option options [String, nil] :suffix The index suffix
+      # @see Esse::Transport#index_exist?
+      def index_exist?(suffix: nil)
+        cluster.api.index_exist?(index: index_name(suffix: suffix))
+      end
+
+      # Deletes an existing index.
+      #
+      #   UsersIndex.delete_index # deletes `<cluster.index_prefix>users<index_suffix>` index
+      #
+      # @param suffix [String, nil] The index suffix Use nil if you want to delete the current index.
+      # @raise [Esse::Transport::NotFoundError] when index does not exists
+      # @return [Hash] elasticsearch response
+      def delete_index(suffix: nil, **options)
+        index = suffix ? index_name(suffix: suffix) : indices_pointing_to_alias.first
+        index ||= index_name
+        cluster.api.delete_index(**options, index: index)
+      end
+
+      # Open a previously closed index
+      #
+      # @option options [String, nil] :suffix The index suffix
+      # @see Esse::Transport#open
+      def open(suffix: nil, **options)
+        cluster.api.open(index: index_name(suffix: suffix), **options)
+      end
+
+      # Close an index (keep the data on disk, but deny operations with the index).
+      #
+      # @option options [String, nil] :suffix The index suffix
+      # @see Esse::Transport#close
+      def close(suffix: nil, **options)
+        cluster.api.close(index: index_name(suffix: suffix), **options)
+      end
+
+      # Performs the refresh operation in one or more indices.
+      #
+      # @note The refresh operation can adversely affect indexing throughput when used too frequently.
+      # @param :suffix [String, nil] :suffix The index suffix
+      # @see Esse::Transport#refresh
+      def refresh(suffix: nil, **options)
+        cluster.api.refresh(index: index_name(suffix: suffix), **options)
+      end
+
+      # Updates index mappings
+      #
+      # @param :suffix [String, nil] :suffix The index suffix
+      # @see Esse::Transport#update_mapping
+      def update_mapping(suffix: nil, **options)
+        body = mappings_hash.fetch(Esse::MAPPING_ROOT_KEY)
+        if (type = options[:type])
+          # Elasticsearch <= 5.x should submit request with type both in the path and in the body
+          # Elasticsearch 6.x should submit request with type in the path but not in the body
+          # Elasticsearch >= 7.x does not support type in the mapping
+          body = body[type.to_s] || body[type.to_sym] || body
+        end
+        cluster.api.update_mapping(index: index_name(suffix: suffix), body: body, **options)
+      end
+
+      # Updates index settings
+      #
+      # @param :suffix [String, nil] :suffix The index suffix
+      # @see Esse::Transport#update_settings
+      def update_settings(suffix: nil, **options)
+        response = nil
+
+        settings = HashUtils.deep_transform_keys(settings_hash.fetch(Esse::SETTING_ROOT_KEY), &:to_s)
+        if options[:body]
+          settings = settings.merge(HashUtils.deep_transform_keys(options.delete(:body), &:to_s))
+        end
+        settings.delete('number_of_shards') # Can't change number of shards for an index
+        settings['index']&.delete('number_of_shards')
+        analysis = settings.delete('analysis')
+
+        if settings.any?
+          response = cluster.api.update_settings(index: index_name(suffix: suffix), body: settings, **options)
+        end
+
+        if analysis
+          # It is also possible to define new analyzers for the index. But it is required to close the
+          # index first and open it after the changes are made.
+          close(suffix: suffix)
+          begin
+            response = cluster.api.update_settings(index: index_name(suffix: suffix), body: { analysis: analysis }, **options)
+          ensure
+            self.open(suffix: suffix)
+          end
+        end
+
+        response
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/esse/index/object_document_mapper.rb

@@ -3,57 +3,6 @@
 module Esse
   class Index
     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 :user do |model, **context|
-      #     {
-      #       id: model.id,
-      #       admin: context[:is_admin],
-      #     }
-      #   end
-      # Example with serializer class
-      #   serializer UserSerializer
-      def serializer(*args, &block)
-        repo_name, klass = args
-        # >> Backward compatibility for the old collection syntax without explicit repo_name
-        if repo_name && klass.nil? && !repo_name.is_a?(String) && !repo_name.is_a?(Symbol)
-          klass = repo_name
-          repo_name = DEFAULT_REPO_NAME
-        end
-        repo_name = repo_name&.to_s || DEFAULT_REPO_NAME
-        # <<
-        find_or_define_repo(repo_name).serializer(klass, &block)
-      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 :admin, AdminStore
-      #   collection :user 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(*args, **kwargs, &block)
-        repo_name, collection_klass = args
-        # >> Backward compatibility for the old collection syntax without explicit repo_name
-        if repo_name && !repo_name.is_a?(Symbol) && !repo_name.is_a?(String) && collection_klass.nil?
-          collection_klass = repo_name
-          repo_name = DEFAULT_REPO_NAME
-        end
-        repo_name = repo_name&.to_s || DEFAULT_REPO_NAME
-        # <<
-        find_or_define_repo(repo_name).collection(collection_klass, **kwargs, &block)
-      end
-
       # Wrap collection data into serialized batches
       #
       # @param [String, NilClass] repo_name The repository identifier
@@ -80,14 +29,6 @@ module Esse
           end
         end
       end
-
-      private
-
-      def find_or_define_repo(repo_name)
-        return repo_hash[repo_name] if repo_hash.key?(repo_name)
-
-        repository(repo_name) {}
-      end
     end
 
     extend ObjectDocumentMapper

data/lib/esse/index/type.rb

@@ -24,7 +24,7 @@ module Esse
 
             repository :#{name} do
               # collection ...
-              # serializer ...
+              # document ...
             end
         MSG
       end
@@ -37,7 +37,7 @@ module Esse
 
       def repository(repo_name, *_args, **kwargs, &block)
         repo_class = Class.new(Esse::Repository)
-        kwargs[:const] ||= true # TODO Change this to false to avoid collisions with application classes
+        kwargs[:const] = true unless kwargs.key?(:const) # TODO Change this to false to avoid collisions with application classes
         kwargs[:lazy_evaluate] ||= false
 
         if kwargs[:const]
@@ -48,7 +48,6 @@ module Esse
 
         repo_class.send(:define_singleton_method, :index) { index }
         repo_class.send(:define_singleton_method, :repo_name) { repo_name.to_s }
-        repo_class.document_type = (kwargs[:document_type] || repo_name).to_s
 
         plugins.each do |mod|
           next unless mod.const_defined?(:RepositoryClassMethods, false)

data/lib/esse/index.rb

@@ -17,10 +17,11 @@ module Esse
     require_relative 'index/settings'
     require_relative 'index/mappings'
     require_relative 'index/descendants'
-    require_relative 'index/backend'
     require_relative 'index/object_document_mapper'
+    # Methods that use the cluster API
+    require_relative 'index/aliases'
+    require_relative 'index/indices'
     require_relative 'index/search'
-
-    def_Index(::Esse)
+    require_relative 'index/documents'
   end
 end

data/lib/esse/null_document.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Esse
-  class NullDocument < Esse::Serializer
+  class NullDocument < Esse::Document
     def initialize
       @object = nil
       @options = {}

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

@@ -3,10 +3,9 @@
 module Esse
   class Repository
     module ClassMethods
-      def elasticsearch
-        Esse::Backend::RepositoryBackend.new(self)
+      def import(**kwargs)
+        index.import(repo_name, **kwargs)
       end
-      alias_method :backend, :elasticsearch
     end
 
     extend ClassMethods