es-elasticity 0.14.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77be59b21060843a1cfd378874a25d43c99b7cda2c264c4aa998ff8bcd70a112
-  data.tar.gz: 5dbaf77099a4ce92ca3b241bd07259b34a5e958afa8389f41ed988a995fd5fb5
+  metadata.gz: 8c13e2b279bf48ef4d133c348954b1b8b19c07a9e3f8af7e539d3bf0e359f485
+  data.tar.gz: d9ca4629b1c2c091fb77cac05213b944ef4d877a845f3d6c8e606a37cfbc6fec
 SHA512:
-  metadata.gz: 8a0194b307ca27ac3b1359edc2181c0541edd7ed36ce3de02d8be8d0be4b93bdce4ab00780bf6fd4305a852542348cbc9047493f68a3afb98456d9f4995a3046
-  data.tar.gz: b26720d7fa9987c315caa4f7bb08e2eb3d23fb893d8e0b388647a3555d0cfb654348d204249e8afacb2812799877c9225da413bbc1d114294e09b6a8c46a35c4
+  metadata.gz: 01d086f62d915982aeae1fa1135836f8442c6eb578ff8c6daa1bfcb8bd4d70b0e54647a38e3b8d22fac0a477afc6ff11cfcc832215acca5d93f8db4d70344065
+  data.tar.gz: 8df1713fd97df4ce332d48a72b6ae9e364a591cc17ca19f6e6a3c621157f595936c84122b8d515ccc18044e2f272da891e2ab22bce4445cc24c00cd112cb74c0

data/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+## [1.0.1] - 2022-08-16
+### Changed
+- Revert the additional `frozen_string_literal` updates in 1.0.0 due to some issues with some classes. We'll update these in a separate release to isolate the problem.
+
+## [1.0.0] - 2022-08-09
+### Changed
+- Consistently use quotations
+- Update API to remove deprecation warnings for Elasticsearch 7.X.X in preparation for upgrade to 8.
+- Freeze string literals
+- Remove `_type` from query/create/update/delete methods
+- Remove `use_new_timestamp_format` config
+- Remove `include_type_name_on_create` config
+
 ## [0.14.1] - 2022-08-09
 ### Changed
 - Don't publish pre-release builds to RubyGems

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    es-elasticity (0.14.1)
+    es-elasticity (1.0.1)
       activemodel (>= 5.2.0, < 7.1)
       activerecord (>= 5.2.0, < 7.1)
       activesupport (>= 5.2.0, < 7.1)

data/README.md

@@ -29,9 +29,10 @@ Or install it yourself as:
 ## Usage
 
 ### Version Support
-This gem has [elasticsearch-ruby](https://github.com/elastic/elasticsearch-ruby) as a dependency.  In order to use different versions of elasticsearch you will need to match your version of elasticsearch-ruby to the version of elasticsearch you want to use ([see here](https://github.com/elastic/elasticsearch-ruby#compatibility).  Elasticity should work across all versions of elastisearch-ruby, although they have not all been tested so there are likely edge cases.
 
-Currently tests are run on CirlceCI against elasticsearch 6.8.2 with elasticsearch-ruby 7.2.0.
+This gem has [elasticsearch-ruby](https://github.com/elastic/elasticsearch-ruby) as a dependency. In order to use different versions of elasticsearch you will need to match your version of elasticsearch-ruby to the version of elasticsearch you want to use ([see here](https://github.com/elastic/elasticsearch-ruby#compatibility). Elasticity should work across all versions of elastisearch-ruby, although they have not all been tested so there are likely edge cases.
+
+Currently tests are run on CirlceCI against elasticsearch 7.17.3 with elasticsearch-ruby 7.17.1.
 
 ### Configuration
 
@@ -149,7 +150,6 @@ documents = [
 Search::User.bulk_update(documents)
 ```
 
-
 ### Searching
 
 Class methods have access to the `search` method, which returns a lazy evaluated search. That means that the search will only be performed when the data is necessary, not when the `search` method is called.
@@ -194,7 +194,8 @@ adults = adults.active_records(User)
 #### Search Args
 
 ##### explain: true
-For `search` definitions we support passing  `{ explain: true }` to the search as a second argument in order to surface the reason a search result was returned.
+
+For `search` definitions we support passing `{ explain: true }` to the search as a second argument in order to surface the reason a search result was returned.
 
 ```ruby
 # example in single search
@@ -211,6 +212,7 @@ multi = Elasticity::MultiSearch.new do |m|
   m.add(:c, search_c, documents: ::SearchDoc::C)
 end
 ```
+
 For more information about the `active_records` method, read [ActiveRecord integration](#activerecord-integration).
 
 ### Segmented Documents
@@ -324,15 +326,15 @@ When the mapping needs to change, a hot remapping can be performed by doing the
 1. Create a new index with the new mapping;
 2. change the update alias to point to the new index, and change main alias to point to both indexes; at this point it will look something like this:
 
-  ```
-  |¯¯¯¯¯¯¯¯¯¯¯¯¯|----------------------> |¯¯¯¯¯¯¯¯¯¯¯¯¯|
-  |  MainAlias  |                        |  Old Index  |
-  |_____________|----------|             |_____________|
-                           |
-  |¯¯¯¯¯¯¯¯¯¯¯¯¯|          |-----------> |¯¯¯¯¯¯¯¯¯¯¯¯¯|
-  | UpdateAlias |----------------------> |  New Index  |
-  |_____________|                        |_____________|
-  ```
+```
+|¯¯¯¯¯¯¯¯¯¯¯¯¯|----------------------> |¯¯¯¯¯¯¯¯¯¯¯¯¯|
+|  MainAlias  |                        |  Old Index  |
+|_____________|----------|             |_____________|
+                         |
+|¯¯¯¯¯¯¯¯¯¯¯¯¯|          |-----------> |¯¯¯¯¯¯¯¯¯¯¯¯¯|
+| UpdateAlias |----------------------> |  New Index  |
+|_____________|                        |_____________|
+```
 
 3. iterate over all documents on the old index, copying them to the new index;
 4. change aliases to point only to the new index;
@@ -344,43 +346,43 @@ This is a simplified version, there are other things that happen to ensure consi
 
 ActiveRecord integration is mainly a set of conventions rather than implementation, with the exception of one method that allows mapping documents back to a relation. Here is the list of conventions:
 
-* have a class method on the document called `from_active_record` that creates a document object from the active record object;
-* have a class method on the Document for rebuilding the index from the records;
-* have an `after_save` and an `after_destroy` callbacks on the ActiveRecord model;
+- have a class method on the document called `from_active_record` that creates a document object from the active record object;
+- have a class method on the Document for rebuilding the index from the records;
+- have an `after_save` and an `after_destroy` callbacks on the ActiveRecord model;
 
 For example:
 
-  ```ruby
-  class User < ActiveRecord::Base
-    after_save    :update_index_document
-    after_destroy :delete_index_document
+```ruby
+class User < ActiveRecord::Base
+  after_save    :update_index_document
+  after_destroy :delete_index_document
 
-    def update_index_document
-      Search::User.from_active_record(self).update
-    end
+  def update_index_document
+    Search::User.from_active_record(self).update
+  end
 
-    def delete_index_document
-      Search::User.delete(self.id)
-    end
+  def delete_index_document
+    Search::User.delete(self.id)
   end
+end
 
-  class Search::User < Elasticity::Document
-    # ... configuration
+class Search::User < Elasticity::Document
+  # ... configuration
 
-    def self.from_active_record(ar)
-      new(name: ar.name, birthdate: ar.birthdate)
-    end
+  def self.from_active_record(ar)
+    new(name: ar.name, birthdate: ar.birthdate)
+  end
 
-    def self.rebuild_index
-      self.recreate_index
+  def self.rebuild_index
+    self.recreate_index
 
-      User.find_in_batches do |batch|
-        documents = batch.map { |record| from_active_record(record) }
-        self.bulk_index(documents)
-      end
+    User.find_in_batches do |batch|
+      documents = batch.map { |record| from_active_record(record) }
+      self.bulk_index(documents)
     end
   end
-  ```
+end
+```
 
 This makes the code very clear in intent, easier to see when and how things happen and under the developer control, keeping both parts very decoupled.
 
@@ -417,6 +419,7 @@ Search::User.adults.active_records(User.where(active: true))
 ```
 
 ## Upgrading from 0.7.0 to 0.8.0
+
 The default persistence strategy changed from SingleIndex to AliasIndex in version 0.8.0 Add the following to your Document configuration to maintain the legacy behaviour.
 
 ```ruby
@@ -424,6 +427,7 @@ The default persistence strategy changed from SingleIndex to AliasIndex in versi
 ```
 
 ## Roadmap
+
 - [ ] Define from_active_record interface
 - [ ] Write more detailed documentation section for:
   - [ ] Model definition

data/es-elasticity.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'elasticity/version'
+require "elasticity/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "es-elasticity"

data/lib/elasticity/base_document.rb

@@ -60,7 +60,7 @@ module Elasticity
     end
 
     def self.default_document_type
-      self.name.gsub('::', '_').underscore
+      self.name.gsub("::", "_").underscore
     end
 
     def self.default_index_base_name

data/lib/elasticity/bulk.rb

@@ -5,16 +5,16 @@ module Elasticity
       @operations = []
     end
 
-    def index(index_name, type, id, attributes)
-      @operations << { index: { _index: index_name, _type: type, _id: id, data: attributes }}
+    def index(index_name, id, attributes)
+      @operations << { index: { _index: index_name, _id: id, data: attributes }}
     end
 
-    def update(index_name, type, id, attributes)
-      @operations << { update: { _index: index_name, _type: type, _id: id, data: attributes }}
+    def update(index_name, id, attributes)
+      @operations << { update: { _index: index_name, _id: id, data: attributes }}
     end
 
-    def delete(index_name, type, id)
-      @operations << { delete: { _index: index_name, _type: type, _id: id }}
+    def delete(index_name, id)
+      @operations << { delete: { _index: index_name, _id: id }}
     end
 
     def execute
@@ -27,16 +27,16 @@ module Elasticity
         @index_name = index_name
       end
 
-      def index(type, id, attributes)
-        super(@index_name, type, id, attributes)
+      def index(id, attributes)
+        super(@index_name, id, attributes)
       end
 
-      def update(type, id, attributes)
-        super(@index_name, type, id, attributes)
+      def update(id, attributes)
+        super(@index_name, id, attributes)
       end
 
-      def delete(type, id)
-        super(@index_name, type, id)
+      def delete(id)
+        super(@index_name, id)
       end
     end
 
@@ -47,17 +47,17 @@ module Elasticity
         @delete_indexes = delete_indexes
       end
 
-      def index(type, id, attributes)
-        super(@update_alias, type, id, attributes)
+      def index(id, attributes)
+        super(@update_alias, id, attributes)
       end
 
-      def update(type, id, attributes)
-        super(@update_alias, type, id, attributes)
+      def update(id, attributes)
+        super(@update_alias, id, attributes)
       end
 
-      def delete(type, id)
+      def delete(id)
         @delete_indexes.each do |index|
-          super(index, type, id)
+          super(index, id)
         end
       end
     end

data/lib/elasticity/index_config.rb

@@ -2,17 +2,18 @@ module Elasticity
   class IndexConfig
     class SubclassError < StandardError; end
 
-    SUBCLASSES_WARNING = "Indices created in Elasticsearch 6.0.0 or later may only contain a single mapping type. " +
+    SUBCLASSES_WARNING = "Indices created in Elasticsearch 6.0.0 or later may only contain a single mapping type. "\
       "Therefore, doument-type based inheritance has been disabled by Elasticity"
-    SUBCLASSES_ERROR = "Mapping types have been completely removed in Elasticsearch 7.0.0. " +
+    SUBCLASSES_ERROR = "Mapping types have been completely removed in Elasticsearch 7.0.0. "\
       "Therefore, doument-type based inheritance has been disabled by Elasticity"
-    VERSION_FOR_SUBCLASS_WARNING = "6.0.0".freeze
-    VERSION_FOR_SUBCLASS_ERROR = "7.0.0".freeze
+    VERSION_FOR_SUBCLASS_WARNING = "6.0.0"
+    VERSION_FOR_SUBCLASS_ERROR = "7.0.0"
     ATTRS = [
       :index_base_name, :document_type, :mapping, :strategy, :subclasses,
       :settings, :use_new_timestamp_format, :include_type_name_on_create
     ].freeze
     VALIDATABLE_ATTRS = [:index_base_name, :document_type, :strategy].freeze
+    DEPRECATED_ATTRS = [:use_new_timestamp_format, :include_type_name_on_create].freeze
 
     attr_accessor(*ATTRS)
 
@@ -23,6 +24,7 @@ module Elasticity
       @elasticity_config = elasticity_config
       yield(self)
       subclasses_warning_or_exception
+      warn_deprecated_config
       validate!
     end
 
@@ -38,9 +40,10 @@ module Elasticity
 
     def definition
       return @definition if defined?(@definition)
+
       @definition = {
         settings: merge_settings,
-        mappings: { @document_type => @mapping.nil? ? {} : @mapping.deep_stringify_keys }
+        mappings: @mapping.nil? ? {} : @mapping.deep_stringify_keys
       }
       subclasses.each do |doc_type, subclass|
         @definition[:mappings][doc_type] = subclass.constantize.mapping
@@ -80,6 +83,15 @@ module Elasticity
       @elasticity_config.settings.merge(settings || {})
     end
 
+    def warn_deprecated_config
+      DEPRECATED_ATTRS.each do |attr|
+        ActiveSupport::Deprecation.warn(
+          "#{attr} is deprecated and will be "\
+          "removed in the next major release."
+        ) if public_send(attr).present?
+      end
+    end
+
     def subclasses_warning_or_exception
       return if subclasses.nil? || subclasses.empty?
       raise(SubclassError.new(SUBCLASSES_ERROR)) if es_version_meets_or_exceeds?(VERSION_FOR_SUBCLASS_ERROR)

data/lib/elasticity/index_mapper.rb

@@ -84,7 +84,7 @@ module Elasticity
 
     # Index the given document
     def index_document(id, document_hash)
-      @strategy.index_document(document_type, id, document_hash)
+      @strategy.index_document(id, document_hash)
     end
 
     # Searches the index using the parameters provided in the body hash, following the same
@@ -99,25 +99,25 @@ module Elasticity
 
     # Fetches one specific document from the index by ID.
     def get(id)
-      doc = @strategy.get_document(document_type, id)
-      @document_klass.new(doc["_source"].merge(_id: doc['_id'])) if doc.present?
+      doc = @strategy.get_document(id)
+      @document_klass.new(doc["_source"].merge(_id: doc["_id"])) if doc.present?
     end
 
     # Removes one specific document from the index.
     def delete(id)
-      @strategy.delete_document(document_type, id)
+      @strategy.delete_document(id)
     end
 
     # Removes entries based on a search
     def delete_by_search(search)
-      @strategy.delete_by_query(document_type, search.body)
+      @strategy.delete_by_query(search.body)
     end
 
     # Bulk index the provided documents
     def bulk_index(documents)
       @strategy.bulk do |b|
         documents.each do |doc|
-          b.index(document_type, doc._id, doc.to_document)
+          b.index(doc._id, doc.to_document)
         end
       end
     end
@@ -127,7 +127,6 @@ module Elasticity
       @strategy.bulk do |b|
         documents.each do |doc|
           b.update(
-            document_type,
             doc[:_id],
             { doc: { doc[:attr_name] => doc[:attr_value] } }
           )
@@ -139,7 +138,7 @@ module Elasticity
     def bulk_delete(ids)
       @strategy.bulk do |b|
         ids.each do |id|
-          b.delete(document_type, id)
+          b.delete(id)
         end
       end
     end
@@ -156,7 +155,7 @@ module Elasticity
 
       if hit["highlight"]
         highlighted_attrs = hit["highlight"].each_with_object({}) do |(name, v), attrs|
-          name = name.gsub(/\..*\z/, '')
+          name = name.gsub(/\..*\z/, "")
 
           attrs[name] ||= v
         end

data/lib/elasticity/railtie.rb

@@ -2,7 +2,7 @@ require "elasticity/log_subscriber"
 
 module Elasticity
   class Railtie < Rails::Railtie
-    initializer 'elasticity.initialize_logging' do
+    initializer "elasticity.initialize_logging" do
       LogSubscriber.attach_to(:elasticity)
     end
   end

data/lib/elasticity/search.rb

@@ -6,7 +6,7 @@ module Elasticity
     end
 
     # Elasticity::Search::Definition is a struct that encapsulates all the data specific to one
-    # ElasticSearch search.
+    # Elasticsearch search.
     class Definition
       attr_accessor :index_name, :document_types, :body
 
@@ -22,20 +22,20 @@ module Elasticity
       end
 
       def to_count_args
-        { index: @index_name, type: @document_types}.tap do |args|
+        { index: @index_name }.tap do |args|
           body = @body.slice(:query)
           args[:body] = body if body.present?
         end
       end
 
       def to_search_args
-        @search_args.merge({ index: @index_name, type: @document_types, body: @body })
+        @search_args.merge({ index: @index_name, body: @body })
       end
 
       def to_msearch_args
         search_body = @search_args.merge(@body)
 
-        { index: @index_name, type: @document_types, search: search_body }
+        { index: @index_name, search: search_body }
       end
     end
 

data/lib/elasticity/strategies/alias_index.rb

@@ -4,24 +4,18 @@ module Elasticity
     # runtime changes by simply atomically updating the aliases. For example, look at the remap method
     # implementation.
     class AliasIndex
-      SNAPSHOT_ERROR_SNIPPET =  "Cannot delete indices that are being snapshotted".freeze
+      SNAPSHOT_ERROR_SNIPPET =  "Cannot delete indices that are being snapshotted"
       RETRYABLE_ERROR_SNIPPETS = [
         SNAPSHOT_ERROR_SNIPPET
       ].freeze
 
       STATUSES = [:missing, :ok]
 
-      def initialize(client, index_base_name, document_type, use_new_timestamp_format = true, include_type_name_on_create = true)
+      def initialize(client, index_base_name, document_type, use_new_timestamp_format = nil, include_type_name_on_create = nil)
         @client       = client
         @main_alias   = index_base_name
         @update_alias = "#{index_base_name}_update"
         @document_type = document_type
-
-        # Deprecated: The use_new_timestamp_format option is no longer used and will be removed in the next version.
-        @use_new_timestamp_format = use_new_timestamp_format
-
-        # included for compatibility with v7
-        @include_type_name_on_create = include_type_name_on_create
       end
 
       def ref_index_name
@@ -63,22 +57,22 @@ module Elasticity
           })
 
           @client.index_refresh(index: original_index)
-          cursor = @client.search index: original_index, search_type: :query_then_fetch, scroll: '10m', size: 100
+          cursor = @client.search index: original_index, search_type: :query_then_fetch, scroll: "10m", size: 100
           loop do
-            hits   = cursor['hits']['hits']
+            hits   = cursor["hits"]["hits"]
             break if hits.empty?
 
             # Fetch documents based on the ids that existed when the migration started, to make sure we only migrate
             # documents that haven't been deleted.
             id_docs = hits.map do |hit|
-              { _index: original_index, _type: hit["_type"], _id: hit["_id"] }
+              { _index: original_index, _id: hit["_id"] }
             end
 
             docs = @client.mget(body: { docs: id_docs }, refresh: true)["docs"]
             break if docs.empty?
 
             # Modify document hashes to match the mapping definition so that legacy fields aren't added
-            defined_mapping_fields = index_def[:mappings][docs.first["_type"]]["properties"].keys
+            defined_mapping_fields = index_def[:mappings]["properties"].keys
 
             # Move only documents that still exists on the old index, into the new index.
             ops = []
@@ -86,7 +80,7 @@ module Elasticity
               if doc["found"]
                 legacy_fields = doc["_source"].keys - defined_mapping_fields
                 legacy_fields.each { |field| doc["_source"].delete(field) }
-                ops << { index: { _index: new_index, _type: doc["_type"], _id: doc["_id"], data: doc["_source"] } }
+                ops << { index: { _index: new_index, _id: doc["_id"], data: doc["_source"] } }
               end
             end
 
@@ -96,12 +90,12 @@ module Elasticity
             ops = []
             @client.mget(body: { docs: id_docs }, refresh: true)["docs"].each_with_index do |new_doc, idx|
               if docs[idx]["found"] && !new_doc["found"]
-                ops << { delete: { _index: new_index, _type: new_doc["_type"], _id: new_doc["_id"] } }
+                ops << { delete: { _index: new_index, _id: new_doc["_id"] } }
               end
             end
 
             @client.bulk(body: ops) unless ops.empty?
-            cursor = @client.scroll(scroll_id: cursor['_scroll_id'], scroll: '1m', body: { scroll_id: cursor["_scroll_id"] })
+            cursor = @client.scroll(scroll_id: cursor["_scroll_id"], scroll: "1m", body: { scroll_id: cursor["_scroll_id"] })
           end
 
           # Update aliases to only point to the new index.
@@ -133,19 +127,19 @@ module Elasticity
           })
 
           @client.index_refresh(index: new_index)
-          cursor = @client.search index: new_index, search_type: :query_then_fetch, scroll: '1m', size: 100
+          cursor = @client.search index: new_index, search_type: :query_then_fetch, scroll: "1m", size: 100
           loop do
-            hits   = cursor['hits']['hits']
+            hits   = cursor["hits"]["hits"]
             break if hits.empty?
 
             # Move all the documents that exists on the new index back to the old index
             ops = []
             hits.each do |doc|
-              ops << { index: { _index: original_index, _type: doc["_type"], _id: doc["_id"], data: doc["_source"] } }
+              ops << { index: { _index: original_index, _id: doc["_id"], data: doc["_source"] } }
             end
 
             @client.bulk(body: ops)
-            cursor = @client.scroll(scroll_id: cursor['_scroll_id'], scroll: '1m')
+            cursor = @client.scroll(scroll_id: cursor["_scroll_id"], scroll: "1m")
           end
 
           @client.index_refresh(index: original_index)
@@ -224,8 +218,8 @@ module Elasticity
         create(index_def)
       end
 
-      def index_document(type, id, attributes)
-        res = @client.index(index: @update_alias, type: type, id: id, body: attributes)
+      def index_document(id, attributes)
+        res = @client.index(index: @update_alias, id: id, body: attributes)
 
         if id = res["_id"]
           [id, res["_shards"] && res["_shards"]["successful"].to_i > 0]
@@ -234,24 +228,24 @@ module Elasticity
         end
       end
 
-      def delete_document(type, id)
+      def delete_document(id)
         ops = (main_indexes | update_indexes).map do |index|
-          { delete: { _index: index, _type: type, _id: id } }
+          { delete: { _index: index, _id: id } }
         end
 
         @client.bulk(body: ops)
       end
 
-      def get_document(type, id)
-        @client.get(index: @main_alias, type: type, id: id)
+      def get_document(id)
+        @client.get(index: @main_alias, id: id)
       end
 
       def search_index
         @main_alias
       end
 
-      def delete_by_query(type, body)
-        @client.delete_by_query(index: @main_alias, type: type, body: body)
+      def delete_by_query(body)
+        @client.delete_by_query(index: @main_alias, body: body)
       end
 
       def bulk
@@ -269,21 +263,21 @@ module Elasticity
       end
 
       def settings
-        @client.index_get_settings(index: @main_alias, type: @document_type).values.first
+        @client.index_get_settings(index: @main_alias).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end
 
       def mappings
         ActiveSupport::Deprecation.warn(
-          'Elasticity::Strategies::AliasIndex#mappings is deprecated, '\
-          'use mapping instead'
+          "Elasticity::Strategies::AliasIndex#mappings is deprecated, "\
+          "use mapping instead"
         )
         mapping
       end
 
       def mapping
-        @client.index_get_mapping(index: @main_alias, type: @document_type, include_type_name: @include_type_name_on_create).values.first
+        @client.index_get_mapping(index: @main_alias).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end
@@ -297,7 +291,7 @@ module Elasticity
 
       def create_index(index_def)
         name = build_index_name
-        @client.index_create(index: name, body: index_def, include_type_name: @include_type_name_on_create)
+        @client.index_create(index: name, body: index_def)
         name
       end
 

data/lib/elasticity/strategies/single_index.rb

@@ -3,16 +3,10 @@ module Elasticity
     class SingleIndex
       STATUSES = [:missing, :ok]
 
-      def initialize(client, index_name, document_type, use_new_timestamp_format = true, include_type_name_on_create = true)
+      def initialize(client, index_name, document_type, use_new_timestamp_format = nil, include_type_name_on_create = nil)
         @client        = client
         @index_name    = index_name
         @document_type = document_type
-
-        # included for compatibility with v7
-        @include_type_name_on_create = include_type_name_on_create
-
-        # Deprecated: The use_new_timestamp_format option is no longer used and will be removed in the next version.
-        @use_new_timestamp_format = use_new_timestamp_format
       end
 
       def ref_index_name
@@ -29,7 +23,7 @@ module Elasticity
 
       def create(index_def)
         if missing?
-          @client.index_create(index: @index_name, body: index_def, include_type_name: @include_type_name_on_create)
+          @client.index_create(index: @index_name, body: index_def)
         else
           raise IndexError.new(@index_name, "index already exist")
         end
@@ -52,8 +46,8 @@ module Elasticity
         create(index_def)
       end
 
-      def index_document(type, id, attributes)
-        res = @client.index(index: @index_name, type: type, id: id, body: attributes)
+      def index_document(id, attributes)
+        res = @client.index(index: @index_name, id: id, body: attributes)
 
         if id = res["_id"]
           [id, res["created"]]
@@ -62,20 +56,20 @@ module Elasticity
         end
       end
 
-      def delete_document(type, id)
-        @client.delete(index: @index_name, type: type, id: id)
+      def delete_document(id)
+        @client.delete(index: @index_name, id: id)
       end
 
-      def get_document(type, id)
-        @client.get(index: @index_name, type: type, id: id)
+      def get_document(id)
+        @client.get(index: @index_name, id: id)
       end
 
       def search_index
         @index_name
       end
 
-      def delete_by_query(type, body)
-        @client.delete_by_query(index: @index_name, type: type, body: body)
+      def delete_by_query(body)
+        @client.delete_by_query(index: @index_name, body: body)
       end
 
       def bulk
@@ -85,21 +79,21 @@ module Elasticity
       end
 
       def settings
-        @client.index_get_settings(index: @index_name, type: @document_type).values.first
+        @client.index_get_settings(index: @index_name).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end
 
       def mappings
         ActiveSupport::Deprecation.warn(
-          'Elasticity::Strategies::SingleIndex#mappings is deprecated, '\
-          'use mapping instead'
+          "Elasticity::Strategies::SingleIndex#mappings is deprecated, "\
+          "use mapping instead"
         )
         mapping
       end
 
       def mapping
-        @client.index_get_mapping(index: @index_name, type: @document_type, include_type_name: @include_type_name_on_create).values.first
+        @client.index_get_mapping(index: @index_name).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end

data/lib/elasticity/version.rb

@@ -1,3 +1,3 @@
 module Elasticity
-  VERSION = "0.14.1"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: es-elasticity
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 1.0.1
 platform: ruby
 authors:
 - Rodrigo Kochenburger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-09 00:00:00.000000000 Z
+date: 2022-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler