serega 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47eacc613b0a58af4dc552e09e0f55ed731f7e2a852e5c668794e7eb5128be69
-  data.tar.gz: bb9fec8432d12108e374bf15da74a230a4efda994835e9480e795b7222bb9ced
+  metadata.gz: 60cc0f4e593d4600bf316e9c18bd93804008e28deebd5f51c231b632bb3a4eff
+  data.tar.gz: e3bdc8e6a0489a14916d84781dcf61c6a82dedb246a0b5366f324d78ca81d9b2
 SHA512:
-  metadata.gz: d7536453cd03fd6e0f65faf22f85f5a12de61ef2bda50d674cd5b31ab1fba815c4b94d5118d82902f5a434d06112cfdc16757eefd334ba217946f9e920442e05
-  data.tar.gz: 9bcd5c46c1ffa32f95bc02e821e94acd46408e4e65a0861e4738454e24a57767105a5d3a9af48d52c4662a1030819963f11ee8c317c84ed179eb44b282a02c73
+  metadata.gz: 879f46f3bface078c156ad0c89e71b4abc08945754034235d03a688c5613e549d477ae1d24bfa6d0f2c44de1def6266d9b18677ab9fab53ef8341510075806d5
+  data.tar.gz: 45b302b1efc001b9ff3ef35bb9d71bf05e3dcfffbfd35938cf938448b308e9c6c0f74a8f1c1eeceabf8a3bd0eb759f50dd053948664565fbeef2f4b8502841b2

data/README.md

@@ -539,118 +539,165 @@ UserSerializer.to_h(user)
 
 ### Plugin :batch
 
-Adds ability to load nested attributes values in batches.
+Must be used to omit N+1 when loading attributes values.
 
-It can be used to find value for attributes in optimal way:
+User must provide batch loader object to attribute -
+`attribute :foo, batch: {loader: SomeLoader, id_method: :id}`.
 
-- load associations for multiple objects
-- load counters for multiple objects
-- make any heavy calculations for multiple objects only once
-
-After including plugin, attributes gain new `:batch` option:
+Result must be returned as Hash, where each key is one of provided ids.
 
 ```ruby
-attribute :name, batch: { loader: :name_loader, key: :id, default: nil }
+class AppSerializer
+  plugin :batch
+end
+
+class UserSerializer < AppSerializer
+  attribute :comments_count,
+    batch: { loader: SomeLoader, id_method: :id }
+
+  attribute :company,
+    batch: { loader: SomeLoader, id_method: :id },
+    serializer: CompanySerializer
+end
 ```
 
-`:batch` option must be a hash with this keys:
+#### Option :loader
 
-- `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for
-  batch of keys. Receives 3 parameters: keys, context, plan.
-- `key` (required) [Symbol, Proc, callable] - Defines current object identifier.
-  Key is optional if plugin was defined with `default_key` option.
-- `default` (optional) - Default value for attribute.
-  By default it is `nil` or `[]` when attribute has option `many: true`
-  (ex: `attribute :tags, many: true, batch: { ... }`).
+Loaders can be defined as a Proc, a callable value or a named Symbol
+Named loaders should be predefined with
+`config.batch.define(:loader_name) { |ids| ... })`
 
-If `:loader` was defined using name (as Symbol) then batch loader must be
-defined using `config.batch.define(:loader_name) { ... }` method.
+Loader can accept 1 to 3 arguments:
 
-Result of this `:loader` callable must be a **Hash** where:
+1. List of ids (each id will be found by using `:id_method` option)
+1. Context
+1. PlanPoint - a special object containing information about current
+   attribute and all children and parent attributes. It can be used to preload
+   required associations to batch values.
+   See [example](examples/batch_loader.rb) how
+   to find required preloads when using with `:preloads` plugin.
 
-- keys - provided keys
-- values - values for according keys
+```ruby
+class AppSerializer < Serega
+  plugin :batch, id_method: :id
+end
 
-`Batch` plugin can be defined with two specific attributes:
+class UserSerializer < Serega
+  # Define loader as callable object
+  attribute :comments_count,
+    batch: { loader: CountLoader }
 
-- `auto_hide: true` - Marks attributes with defined :batch as hidden, so it
-  will not be serialized by default
-- `default_key: :id` - Set default object key (in this case :id) that will be
-  used for all attributes with :batch option specified.
+  # Define loader as a Proc
+  attribute :comments_count,
+    batch: { loader: proc { |ids| CountLoader.call(ids) } }
 
-```ruby
-  plugin :batch, auto_hide: true, default_key: :id
+  # Define loader as a Symbol
+  config.batch.define(:comments_count_loader) { |ids| CountLoader.call(ids }
+  attribute :comments_count, batch: { loader: :comments_count_loader }
+end
+
+class CountLoader
+  def self.call(user_ids)
+    Comment.where(user_id: user_ids).group(:user_id).count
+  end
+end
 ```
 
-Options `auto_hide` and `default_key` can be overwritten in nested serializers.
+#### Option :id_method
+
+Batch plugin can be added with global `:id_method` option. It can be a Symbol,
+Proc or any callable value, which can accept current object and current context.
 
 ```ruby
-class AppSerializer
-  plugin :batch, auto_hide: true, default_key: :id
+class SomeSerializer
+  plugin :batch, id_method: :id
 end
 
 class UserSerializer < AppSerializer
-  config.batch.auto_hide = false
-  config.batch.default_key = :user_id
+  attribute :comments_count,
+    batch: { loader: CommentsCountBatchLoader } # no :id_method here anymore
+
+  attribute :company,
+    batch: { loader: UserCompanyBatchLoader }, # no :id_method here anymore
+    serializer: CompanySerializer
 end
+
 ```
 
----
-⚠️ ATTENTION: `Batch` plugin must be added to serializers which have no
-`:batch` attributes, but have nested serializers, that have some. For example
-when you serialize `User -> Album -> Song` and Song has `:batch` attribute, then
-`:batch` plugin must be added to the User serializer also. \
-Best way would be to create one parent `AppSerializer < Serega` for all your
-serializers and add `:batch` plugin only to this parent `AppSerializer`
+However, global `id_method` option can be overwritten via `config.batch.id_method=`
+method or in specific attributes with `id_method` option.
 
 ```ruby
-class AppSerializer < Serega
-  plugin :batch, auto_hide: true, default_key: :id
+class SomeSerializer
+  plugin :batch, id_method: :id # global id_method is `:id`
 end
 
-class PostSerializer < AppSerializer
-  attribute :comments_count,
-    batch: {
-      loader: CommentsCountBatchLoader, # callable(keys, context, plan_point)
-      key: :id, # can be skipped (as :id value is same as configured :default_key)
-      default: 0
-    }
+class UserSerializer < AppSerializer
+  # :user_id will be used as default `id_method` for all batch attributes
+  config.batch.id_method = :user_id
 
-  # Define batch loader via Symbol, later we should define this loader via
-  # `config.batch.define(:posts_comments_counter) { ... }`
-  #
-  # Loader will receive array of ids, as `default_key: :id` plugin option was specified.
-  # Default value for not found counters is nil, as `:default` option not defined
+  # id_method is :user_id
   attribute :comments_count,
-    batch: { loader: :posts_comments_counter }
+    batch: { loader: CommentsCountBatchLoader }
 
-  # Define batch loader with serializer
-  attribute :comments,
-    serializer: CommentSerializer,
-    batch: {loader: :posts_comments, default: []}
 
-  # Resulted block must return hash like { key => value(s) }
-  config.batch.define(:posts_comments_counter) do |keys|
-    Comment.group(:post_id).where(post_id: keys).count
-  end
+  # id_method is :user_id
+  attribute :company,
+    batch: { loader: UserCompanyBatchLoader }, serializer: CompanySerializer
 
-  # We can return objects that will be automatically serialized if attribute
-  # defined with :serializer
-  # Parameter `context` can be used when loading batch
-  # Parameter `point` can be used to find nested attributes to serialize
-  config.batch.define(:posts_comments) do |keys, context, point|
-    # point.child_plan - if you need to manually check all nested attributes
-    # point.preloads - nested preloads (works with :preloads plugin only)
-
-    Comment
-      .preload(point.preloads) # Skip if :activerecord_preloads plugin used
-      .where(post_id: keys)
-      .where(is_spam: false)
-      .group_by(&:post_id)
-  end
+  # id_method is :uuid
+  attribute :points_amount,
+    batch: { loader: PointsBatchLoader, id_method: :uuid }
+end
+```
+
+#### Option :default
+
+The default value for attributes without found value can be specified via
+`:default` option. By default attributes without found value will be
+serialized as `nil`. Attribute marked as `many: true` will be
+serialized as empty array `[]`
+
+```ruby
+class UserSerializer < AppSerializer
+  # Missing values become empty arrays, as `many: true` option specified
+  attribute :companies,
+    batch: {loader: proc {}},
+    serializer: CompanySerializer,
+    many: true
+
+  # Missing values become `0` as specified directly
+  attribute :points_amount,
+    batch: { loader: proc {}, default: 0 }
+end
+```
+
+Batch attributes can be marked as hidden by default if plugin specified with
+`auto_hide` option. Also `auto_hide` option can be changed with
+`config.batch.auto_hide=` method.
+
+Look at [select serialized fields](#selecting-fields) for more information
+about hiding/showing attributes.
+
+```ruby
+class AppSerializer
+  plugin :batch, auto_hide: true
+end
+
+class UserSerializer < AppSerializer
+  config.batch.auto_hide = false
 end
 ```
 
+---
+⚠️ ATTENTION: `Batch` plugin must be added to all serializers that have
+`:batch` attributes inside nested serializers. For example when you serialize
+`User -> Album -> Song` and Song has `batch` attribute, then
+`batch` plugin must be added to the User serializer also.
+
+Best way would be to create one parent `AppSerializer < Serega` serializer
+and add `:batch` plugin once to this parent serializer.
+
 ### Plugin :root
 
 Allows to add root key to your serialized data

data/VERSION

@@ -1 +1 @@
-0.17.0
+0.18.0

data/lib/serega/object_serializer.rb

@@ -29,7 +29,7 @@ class Serega
       #
       # @param object [Object] Serialized object
       #
-      # @return [Hash, Array<Hash>] Serialized object(s)
+      # @return [Hash, Array<Hash>, nil] Serialized object(s)
       def serialize(object)
         return if object.nil?
 

data/lib/serega/plugins/batch/batch.rb

@@ -5,62 +5,17 @@ class Serega
     #
     # Plugin `:batch`
     #
-    # Adds ability to load nested attributes values in batches.
+    # Must be used to omit N+1 when loading attributes values.
     #
-    # It can be used to find value for attributes in optimal way:
-    # - load associations for multiple objects
-    # - load counters for multiple objects
-    # - make any heavy calculations for multiple objects only once
+    # @example Quick example
     #
-    # After including plugin, attributes gain new `:batch` option.
-    #
-    # `:batch` option must be a hash with this keys:
-    # - `key` (required) [Symbol, Proc, callable] - Defines current object identifier.
-    #   Later `loader` will accept array of `keys` to find `values`.
-    # - `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for
-    #   batch of keys. Receives 3 parameters: keys, context, plan_point.
-    # - `default` (optional) - Default value for attribute.
-    #   By default it is `nil` or `[]` when attribute has option `many: true`
-    #
-    # If `:loader` was defined using name (as Symbol) then batch loader must be
-    # defined in serializer config: `config.batch.define(:loader_name) { ... }` method.
-    #
-    # *Result of this `:loader` callable must be a **Hash** where*:
-    # - keys - provided keys
-    # - values - values for according keys
-    #
-    # `Batch` plugin can be defined with two specific attributes:
-    # - `auto_hide: true` - Marks attributes with defined :batch as hidden, so it
-    #   will not be serialized by default
-    # - `default_key: :id` - Set default object key (in this case :id) that will be used for all attributes with :batch option specified.
-    #
-    # This options (`auto_hide`, `default_key`) also can be set as config options in
-    # any nested serializer.
-    #
-    # @example
-    #   class PostSerializer < Serega
-    #     plugin :batch, auto_hide: true, default_key: :id
-    #
-    #     # Define batch loader via callable class, it must accept three args (keys, context, plan_point)
-    #     attribute :comments_count, batch: { loader: PostCommentsCountBatchLoader, default: 0}
-    #
-    #     # Define batch loader via Symbol, later we should define this loader via config.batch.define(:posts_comments_counter) { ... }
-    #     attribute :comments_count, batch: { loader: :posts_comments_counter, default: 0}
-    #
-    #     # Define batch loader with serializer
-    #     attribute :comments, serializer: CommentSerializer, batch: { loader: :posts_comments, default: []}
-    #
-    #     # Resulted block must return hash like { key => value(s) }
-    #     config.batch.define(:posts_comments_counter) do |keys|
-    #       Comment.group(:post_id).where(post_id: keys).count
-    #     end
+    #   class AppSerializer
+    #     plugin :batch, id_method: :id
+    #   end
     #
-    #     # We can return objects that will be automatically serialized if attribute defined with :serializer
-    #     # Parameter `context` can be used when loading batch
-    #     # Parameter `plan_point` can be used to find nested attributes that will be serialized (`plan_point.preloads`)
-    #     config.batch.define(:posts_comments) do |keys, context, plan_point|
-    #       Comment.where(post_id: keys).where(is_spam: false).group_by(&:post_id)
-    #     end
+    #   class UserSerializer < AppSerializer
+    #     attribute :comments_count, batch: { loader: CommentsCountBatchLoader, default: 0 }
+    #     attribute :company, serializer: CompanySerializer, batch: { loader: UserCompanyBatchLoader }
     #   end
     #
     module Batch
@@ -88,7 +43,7 @@ class Serega
         require_relative "lib/modules/config"
         require_relative "lib/modules/object_serializer"
         require_relative "lib/modules/plan_point"
-        require_relative "lib/validations/check_batch_opt_key"
+        require_relative "lib/validations/check_batch_opt_id_method"
         require_relative "lib/validations/check_batch_opt_loader"
         require_relative "lib/validations/check_opt_batch"
 
@@ -138,9 +93,9 @@ class Serega
 
         config = serializer_class.config
         config.attribute_keys << :batch
-        config.opts[:batch] = {loaders: {}, default_key: nil, auto_hide: false}
+        config.opts[:batch] = {loaders: {}, id_method: nil, auto_hide: false}
         config.batch.auto_hide = opts[:auto_hide] if opts.key?(:auto_hide)
-        config.batch.default_key = opts[:default_key] if opts.key?(:default_key)
+        config.batch.id_method = opts[:id_method] if opts.key?(:id_method)
       end
 
       #

data/lib/serega/plugins/batch/lib/batch_config.rb

@@ -17,8 +17,8 @@ class Serega
         # Defines batch loader
         #
         # @param loader_name [Symbol] Batch loader name, that is used when defining attribute with batch loader.
-        # @param block [Proc] Block that can accept 3 parameters - keys, context, plan_point
-        #   and returns hash where ids are keys and values are batch loaded objects/
+        # @param block [Proc] Block that can accept 3 parameters - ids, context, plan_point
+        #   and returns hash with ids as keys and values are batch loaded objects
         #
         # @return [void]
         #
@@ -32,7 +32,7 @@ class Serega
           params_count = SeregaUtils::ParamsCount.call(callable, max_count: 3)
 
           if params_count > 3
-            raise SeregaError, "Batch loader can have maximum 3 parameters (keys, context, plan)"
+            raise SeregaError, "Batch loader can have maximum 3 parameters (ids, context, plan)"
           end
 
           loaders[loader_name] = callable
@@ -44,16 +44,6 @@ class Serega
           opts[:loaders]
         end
 
-        #
-        # Finds previously defined batch loader by name
-        #
-        # @param loader_name [Symbol]
-        #
-        # @return [Proc] batch loader block
-        def fetch_loader(loader_name)
-          loaders[loader_name] || (raise SeregaError, "Batch loader with name `#{loader_name.inspect}` was not defined. Define example: config.batch.define(:#{loader_name}) { |keys| ... }")
-        end
-
         # Shows option to auto hide attributes with :batch specified
         # @return [Boolean, nil] option value
         def auto_hide
@@ -67,17 +57,19 @@ class Serega
           opts[:auto_hide] = value
         end
 
-        # Shows default key for :batch option
-        # @return [Symbol, nil] default key for :batch option
-        def default_key
-          opts[:default_key]
+        # Shows method name or callable object needed to get object identifier for batch load
+        # @return [Symbol, #call, nil] Default method name or callable object to get identifier
+        def id_method
+          opts[:id_method]
         end
 
-        # @param value [Symbol] New :default_key option value
+        # Sets new identifier method name or callable value needed for batch loading
+        #
+        # @param value [Symbol, #call] New :id_method value
         # @return [Boolean] New option value
-        def default_key=(value)
-          raise SeregaError, "Must be a Symbol, #{value.inspect} provided" unless value.is_a?(Symbol)
-          opts[:default_key] = value
+        def id_method=(value)
+          CheckBatchOptIdMethod.call(value)
+          opts[:id_method] = value
         end
       end
     end

data/lib/serega/plugins/batch/lib/modules/attribute_normalizer.rb

@@ -44,27 +44,27 @@ class Serega
 
           loader = prepare_batch_loader(batch[:loader])
 
-          key = batch[:key] || self.class.serializer_class.config.batch.default_key
-          key = prepare_batch_key(key)
+          id_method = batch[:id_method] || self.class.serializer_class.config.batch.id_method
+          id_method = prepare_batch_id_method(id_method)
 
           default = batch.fetch(:default) { many ? FROZEN_EMPTY_ARRAY : nil }
 
-          {loader: loader, key: key, default: default}
+          {loader: loader, id_method: id_method, default: default}
         end
 
-        def prepare_batch_key(key)
-          return proc { |object| object.public_send(key) } if key.is_a?(Symbol)
+        def prepare_batch_id_method(id_method)
+          return proc { |object| object.public_send(id_method) } if id_method.is_a?(Symbol)
 
-          params_count = SeregaUtils::ParamsCount.call(key, max_count: 2)
+          params_count = SeregaUtils::ParamsCount.call(id_method, max_count: 2)
           case params_count
-          when 0 then proc { key.call }
-          when 1 then proc { |object| key.call(object) }
-          else key
+          when 0 then proc { id_method.call }
+          when 1 then proc { |object| id_method.call(object) }
+          else id_method
           end
         end
 
         def prepare_batch_loader(loader)
-          return loader if loader.is_a?(Symbol)
+          loader = self.class.serializer_class.config.batch.loaders.fetch(loader) if loader.is_a?(Symbol)
 
           params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
           case params_count

data/lib/serega/plugins/batch/lib/modules/object_serializer.rb

@@ -19,8 +19,8 @@ class Serega
         end
 
         def remember_key_for_batch_loading(batch, object, point, container)
-          key = batch[:key].call(object, context)
-          batch_loader(point).remember(key, container)
+          id = batch[:id_method].call(object, context)
+          batch_loader(point).remember(id, container)
           container[point.name] = nil # Reserve attribute place in resulted hash. We will set correct value later
         end
 

data/lib/serega/plugins/batch/lib/modules/plan_point.rb

@@ -13,25 +13,8 @@ class Serega
         # Returns attribute :batch option with prepared loader
         # @return [Hash] attribute :batch option
         #
-        attr_reader :batch
-
-        private
-
-        def set_normalized_vars
-          super
-          @batch = prepare_batch
-        end
-
-        def prepare_batch
-          batch = attribute.batch
-          if batch
-            loader = batch[:loader]
-            if loader.is_a?(Symbol)
-              batch_config = attribute.class.serializer_class.config.batch
-              batch[:loader] = batch_config.fetch_loader(loader)
-            end
-          end
-          batch
+        def batch
+          attribute.batch
         end
       end
     end

data/lib/serega/plugins/batch/lib/validations/check_batch_opt_id_method.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      #
+      # Validator for option :id_method in attribute :batch option
+      #
+      class CheckBatchOptIdMethod
+        class << self
+          #
+          # Checks option :id_method of attribute :batch option
+          #
+          # @param id [nil, #call] Attribute :batch option :id_method
+          #
+          # @raise [SeregaError] validation error
+          #
+          # @return [void]
+          #
+          def call(id)
+            return if id.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless id.respond_to?(:call)
+
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(id, "batch option :id_method")
+            params_count = SeregaUtils::ParamsCount.call(id, max_count: 2)
+            raise SeregaError, params_count_error if params_count > 2
+          end
+
+          private
+
+          def params_count_error
+            "Invalid :batch option :id_method. It can accept maximum 2 parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid :batch option :id_method. It must be a Symbol, a Proc or respond to #call"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/batch/lib/validations/check_batch_opt_loader.rb

@@ -17,9 +17,27 @@ class Serega
           #
           # @return [void]
           #
-          def call(loader)
-            return if loader.is_a?(Symbol)
+          def call(loader, serializer_class)
+            if loader.is_a?(Symbol)
+              check_symbol(loader, serializer_class)
+            else
+              check_callable(loader)
+            end
+          end
+
+          private
+
+          def check_symbol(loader_name, serializer_class)
+            defined_loaders = serializer_class.config.batch.loaders
+            return if defined_loaders[loader_name]
 
+            raise SeregaError, <<~ERR.strip
+              Please define loader before adding it to attribute.
+                Example: `config.batch.define(:#{loader_name}) { |ids| ... }`
+            ERR
+          end
+
+          def check_callable(loader)
             raise SeregaError, must_be_callable unless loader.respond_to?(:call)
 
             SeregaValidations::Utils::CheckExtraKeywordArg.call(loader, ":batch option :loader")
@@ -27,10 +45,8 @@ class Serega
             raise SeregaError, params_count_error if params_count > 3
           end
 
-          private
-
           def params_count_error
-            "Invalid :batch option :loader. It can accept maximum 3 parameters (keys, context, plan)"
+            "Invalid :batch option :loader. It can accept maximum 3 parameters (ids, context, plan)"
           end
 
           def must_be_callable

data/lib/serega/plugins/batch/lib/validations/check_opt_batch.rb

@@ -23,30 +23,29 @@ class Serega
             SeregaValidations::Utils::CheckOptIsHash.call(opts, :batch)
 
             batch = opts[:batch]
-            SeregaValidations::Utils::CheckAllowedKeys.call(batch, %i[key loader default], :batch)
-
-            check_batch_opt_key(batch, serializer_class)
-            check_batch_opt_loader(batch)
+            SeregaValidations::Utils::CheckAllowedKeys.call(batch, %i[id_method loader default], :batch)
 
+            check_batch_opt_id_method(batch, serializer_class)
+            check_batch_opt_loader(batch, serializer_class)
             check_usage_with_other_params(opts, block)
           end
 
           private
 
-          def check_batch_opt_key(batch, serializer_class)
-            return if !batch.key?(:key) && serializer_class.config.batch.default_key
+          def check_batch_opt_id_method(batch, serializer_class)
+            return if !batch.key?(:id_method) && serializer_class.config.batch.id_method
 
-            key = batch[:key]
-            raise SeregaError, "Option :key must present inside :batch option" unless key
+            id_method = batch[:id_method]
+            raise SeregaError, "Option :id_method must present inside :batch option" unless id_method
 
-            CheckBatchOptKey.call(key)
+            CheckBatchOptIdMethod.call(id_method)
           end
 
-          def check_batch_opt_loader(batch)
+          def check_batch_opt_loader(batch, serializer_class)
             loader = batch[:loader]
             raise SeregaError, "Option :loader must present inside :batch option" unless loader
 
-            CheckBatchOptLoader.call(loader)
+            CheckBatchOptLoader.call(loader, serializer_class)
           end
 
           def check_usage_with_other_params(opts, block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-03 00:00:00.000000000 Z
+date: 2023-11-11 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -55,7 +55,7 @@ files:
 - lib/serega/plugins/batch/lib/plugins_extensions/activerecord_preloads.rb
 - lib/serega/plugins/batch/lib/plugins_extensions/formatters.rb
 - lib/serega/plugins/batch/lib/plugins_extensions/preloads.rb
-- lib/serega/plugins/batch/lib/validations/check_batch_opt_key.rb
+- lib/serega/plugins/batch/lib/validations/check_batch_opt_id_method.rb
 - lib/serega/plugins/batch/lib/validations/check_batch_opt_loader.rb
 - lib/serega/plugins/batch/lib/validations/check_opt_batch.rb
 - lib/serega/plugins/camel_case/camel_case.rb
@@ -140,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: JSON Serializer

data/lib/serega/plugins/batch/lib/validations/check_batch_opt_key.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Validator for option :key in attribute :batch option
-      #
-      class CheckBatchOptKey
-        class << self
-          #
-          # Checks option :key of attribute :batch option
-          #
-          # @param key [nil, #call] Attribute :batch option :key
-          #
-          # @raise [SeregaError] validation error
-          #
-          # @return [void]
-          #
-          def call(key)
-            return if key.is_a?(Symbol)
-
-            raise SeregaError, must_be_callable unless key.respond_to?(:call)
-
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(key, "batch option :key")
-            params_count = SeregaUtils::ParamsCount.call(key, max_count: 2)
-            raise SeregaError, params_count_error if params_count > 2
-          end
-
-          private
-
-          def params_count_error
-            "Invalid :batch option :key. It can accept maximum 2 parameters (object, context)"
-          end
-
-          def must_be_callable
-            "Invalid :batch option :key. It must be a Symbol, a Proc or respond to :call"
-          end
-        end
-      end
-    end
-  end
-end