serega 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d780c3d344370b36d9e6db64dfdfa08878bfe32885469610ac2314638c878d87
-  data.tar.gz: d282c6466f7b7205a7b524999b85a3e928d79c00ee11445abd26582e0146842c
+  metadata.gz: 47eacc613b0a58af4dc552e09e0f55ed731f7e2a852e5c668794e7eb5128be69
+  data.tar.gz: bb9fec8432d12108e374bf15da74a230a4efda994835e9480e795b7222bb9ced
 SHA512:
-  metadata.gz: e2a161487df001b0074d1864770a7dfecd77ef788e187de6e460cd3d2856162cba8777eb807a65a8d4d49471bb50380fc49ffd17f36c16eb52a2ab8b84ed7991
-  data.tar.gz: 4a672090d0893ef8d3945b2528fc9861d245833ec4b21074b73481ab7acbf8fa5207c786cad8496bf022070f3341339522bbf4970c7a554cfa543f002f51f504
+  metadata.gz: d7536453cd03fd6e0f65faf22f85f5a12de61ef2bda50d674cd5b31ab1fba815c4b94d5118d82902f5a434d06112cfdc16757eefd334ba217946f9e920442e05
+  data.tar.gz: 9bcd5c46c1ffa32f95bc02e821e94acd46408e4e65a0861e4738454e24a57767105a5d3a9af48d52c4662a1030819963f11ee8c317c84ed179eb44b282a02c73

data/README.md

@@ -17,13 +17,16 @@ objects and to serialize them to Hash or JSON.
 It has some great features:
 
 - Manually [select serialized fields](#selecting-fields)
+- Secure from malicious queries with [depth_limit][depth_limit] plugin
 - Solutions for N+1 problem (via [batch][batch], [preloads][preloads] or
   [activerecord_preloads][activerecord_preloads] plugins)
 - Built-in object presenter ([presenter][presenter] plugin)
 - Adding custom metadata (via [metadata][metadata] or
   [context_metadata][context_metadata] plugins)
-- Attributes formatters ([formatters][formatters] plugin)
-- Conditional attributes ([if][if] plugin)
+- Value formatters ([formatters][formatters] plugin) helps to transform
+  time, date, money, percentage and any other values same way keeping code dry
+- Conditional attributes - ([if][if] plugin)
+- Auto camelCase keys - [camel_case][camel_case] plugin
 
 ## Installation
 
@@ -64,21 +67,23 @@ class UserSerializer < Serega
   # Regular attribute
   attribute :first_name
 
-  # Option :key specifies method in object
-  attribute :first_name, key: :old_first_name
+  # Option :method specifies method that must be called on serialized object
+  attribute :first_name, method: :old_first_name
 
   # Block is used to define attribute value
   attribute(:first_name) { |user| user.profile&.first_name }
 
-  # Option :value can be used with callable object to define attribute value
+  # Option :value can be used with proc or callable object to define attribute value
+  attribute :first_name, value: UserProfile.new # must have #call method
   attribute :first_name, value: proc { |user| user.profile&.first_name }
 
   # Option :delegate can be used to define attribute value.
   # Sub-option :allow_nil by default is false
   attribute :first_name, delegate: { to: :profile, allow_nil: true }
 
-  # Option :delegate can be used with :key sub-option
-  attribute :first_name, delegate: { to: :profile, key: :fname }
+  # Option :delegate can be used with :method sub-option, so method chain here
+  # is user.profile.fname
+  attribute :first_name, delegate: { to: :profile, method: :fname }
 
   # Option :const specifies attribute with specific constant value
   attribute(:type, const: 'user')
@@ -282,7 +287,7 @@ UserSerializer.to_h(bruce, with: fields_as_string)
 
 # With not existing attribute
 fields = %i[first_name enemy]
-fields_as_string = 'first_name,enemy')
+fields_as_string = 'first_name,enemy'
 UserSerializer.new(only: fields).to_h(bruce)
 UserSerializer.to_h(bruce, only: fields)
 UserSerializer.to_h(bruce, only: fields_as_string)
@@ -433,7 +438,7 @@ end
 class UserSerializer < AppSerializer
   attribute :username
   attribute :user_stats,
-    serializer: 'UserStatSerializer'
+    serializer: 'UserStatSerializer',
     value: proc { |user| user },
     preload: nil
 end
@@ -545,15 +550,15 @@ It can be used to find value for attributes in optimal way:
 After including plugin, attributes gain new `:batch` option:
 
 ```ruby
-attribute :name, batch: { key: :id, loader: :name_loader, default: nil }
+attribute :name, batch: { loader: :name_loader, key: :id, default: nil }
 ```
 
 `: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 detect this keys values.
 - `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for
-  batch of keys. Receives 3 parameters: keys, context, plan_point.
+  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: { ... }`).
@@ -711,17 +716,24 @@ Adds ability to describe metadata and adds it to serialized response
 
 Added class-level method `:meta_attribute`, to define metadata, it accepts:
 
-- *path [Array of Symbols] - nested hash keys.
-- **options [Hash] - defaults are `hide_nil: false, hide_empty: false`
-- &block [Proc] - describes value for current meta attribute
+- `*path` [Array of Symbols] - nested hash keys.
+- `**options` [Hash]
+
+   - `:const` - describes metadata value (if it is constant)
+   - `:value` - describes metadata value as any `#callable` instance
+   - `:hide_nil` - does not show metadata key if value is nil, `false` by default
+   - `:hide_empty`, does not show metadata key if value is nil or empty,
+     `false` by default
+
+- `&block` [Proc] - describes value for current meta attribute
 
 ```ruby
 class AppSerializer < Serega
   plugin :root
   plugin :metadata
 
-  meta_attribute(:version) { '1.2.3' }
-  meta_attribute(:ab_tests, :names) { %i[foo bar] }
+  meta_attribute(:version, const: '1.2.3')
+  meta_attribute(:ab_tests, :names, value: ABTests.new.method(:names))
   meta_attribute(:meta, :paging, hide_nil: true) do |records, ctx|
     next unless records.respond_to?(:total_count)
 
@@ -734,7 +746,7 @@ class AppSerializer < Serega
 end
 
 AppSerializer.to_h(nil)
-# => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=>[:foo, :bar]}}
+# => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=> ... }}
 ```
 
 ### Plugin :context_metadata
@@ -765,19 +777,22 @@ UserSerializer.to_h(nil, meta: { version: '1.0.1' })
 
 ### Plugin :formatters
 
-Allows to define `formatters` and apply them on attributes.
+Allows to define `formatters` and apply them on attribute values.
 
 Config option `config.formatters.add` can be used to add formatters.
 
-Attribute option `:format` now can be used with name of formatter or with
+Attribute option `:format` can be used with name of formatter or with
 callable instance.
 
+Formatters can accept up to 2 parameters (formatted object, context)
+
 ```ruby
 class AppSerializer < Serega
   plugin :formatters, formatters: {
     iso8601: ->(value) { time.iso8601.round(6) },
     on_off: ->(value) { value ? 'ON' : 'OFF' },
-    money: ->(value) { value.round(2) }
+    money: ->(value, ctx) { value / 10**ctx[:digits) }
+    date: DateTypeFormatter # callable
   }
 end
 
@@ -888,6 +903,88 @@ Look at [select serialized fields](#selecting-fields) for `:hide` usage examples
  end
 ```
 
+### Plugin :camel_case
+
+By default when we add attribute like `attribute :first_name` this means:
+
+- adding a `:first_name` key to resulted hash
+- adding a `#first_name` method call result as value
+
+But its often desired to response with *camelCased* keys.
+By default this can be achieved by specifying attribute name and method directly
+for each attribute: `attribute :firstName, method: first_name`
+
+This plugin transforms all attribute names automatically.
+We use simple regular expression to replace `_x` to `X` for the whole string.
+We make this transformation only once when attribute is defined.
+
+You can provide your own callable transformation when defining plugin,
+for example `plugin :camel_case, transform: ->(name) { name.camelize }`
+
+For any attribute camelCase-behavior can be skipped when
+`camel_case: false` attribute option provided.
+
+This plugin transforms only attribute keys,
+without affecting `root`, `metadata`, `context_metadata` plugins keys.
+
+If you wish to [select serialized fields](#selecting-fields), you should
+provide them camelCased.
+
+```ruby
+class AppSerializer < Serega
+  plugin :camel_case
+end
+
+class UserSerializer < AppSerializer
+  attribute :first_name
+  attribute :last_name
+  attribute :full_name, camel_case: false,
+    value: proc { |user| [user.first_name, user.last_name].compact.join(" ") }
+end
+
+require "ostruct"
+user = OpenStruct.new(first_name: "Bruce", last_name: "Wayne")
+UserSerializer.to_h(user)
+# => {firstName: "Bruce", lastName: "Wayne", full_name: "Bruce Wayne"}
+
+UserSerializer.new(only: %i[firstName lastName]).to_h(user)
+# => {firstName: "Bruce", lastName: "Wayne"}
+```
+
+### Plugin :depth_limit
+
+Helps to secure from malicious queries that require to serialize too much
+or from accidental serializing of objects with cyclic relations.
+
+Depth limit is checked when constructing a serialization plan, that is when
+`#new` method is called, ex: `SomeSerializer.new(with: params[:with])`.
+It can be useful to instantiate serializer before any other business logic
+to get possible errors earlier.
+
+Any class-level serialization methods also check depth limit as they also
+instantiate serializer.
+
+When depth limit is exceeded `Serega::DepthLimitError` is raised.
+Depth limit error details can be found in additional
+`Serega::DepthLimitError#details` method
+
+Limit can be checked or changed with next config options:
+
+- `config.depth_limit.limit`
+- `config.depth_limit.limit=`
+
+There are no default limit, but it should be set when enabling plugin.
+
+```ruby
+class AppSerializer < Serega
+  plugin :depth_limit, limit: 10 # set limit for all child classes
+end
+
+class UserSerializer < AppSerializer
+  config.depth_limit.limit = 5 # overrides limit for UserSerializer
+end
+```
+
 ### Plugin :explicit_many_option
 
 Plugin requires to add :many option when adding relationships
@@ -941,7 +1038,9 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 [activerecord_preloads]: #plugin-activerecord_preloads
 [batch]: #plugin-batch
+[camel_case]: #plugin-camel_case
 [context_metadata]: #plugin-context_metadata
+[depth_limit]: #plugin-depth_limit
 [formatters]: #plugin-formatters
 [metadata]: #plugin-metadata
 [preloads]: #plugin-preloads

data/VERSION

@@ -1 +1 @@
-0.15.0
+0.17.0

data/lib/serega/attribute.rb

@@ -22,7 +22,7 @@ class Serega
       attr_reader :many
 
       # Attribute :hide option
-      # @return [Boolean nil] Attribute :hide option
+      # @return [Boolean, nil] Attribute :hide option
       attr_reader :hide
 
       #
@@ -30,7 +30,7 @@ class Serega
       #
       # @param name [Symbol, String] Name of attribute
       # @param opts [Hash] Attribute options
-      # @option opts [Symbol] :key Object method name to fetch attribute value
+      # @option opts [Symbol] :method Object method name to fetch attribute value
       # @option opts [Hash] :delegate Allows to fetch value from nested object
       # @option opts [Boolean] :hide Specify `true` to not serialize this attribute by default
       # @option opts [Boolean] :many Specifies has_many relationship. By default is detected via object.is_a?(Enumerable)
@@ -61,10 +61,10 @@ class Serega
       # Shows specified serializer class
       # @return [Serega, nil] Attribute serializer if exists
       def serializer
-        ser = @serializer
-        return ser if (ser.is_a?(Class) && (ser < Serega)) || !ser
+        serializer = @serializer
+        return serializer if (serializer.is_a?(Class) && (serializer < Serega)) || !serializer
 
-        @serializer = ser.is_a?(String) ? Object.const_get(ser, false) : ser.call
+        @serializer = serializer.is_a?(String) ? Object.const_get(serializer, false) : serializer.call
       end
 
       #

data/lib/serega/attribute_normalizer.rb

@@ -36,12 +36,12 @@ class Serega
       end
 
       #
-      # Symbolized initial attribute key or attribute name if key is empty
+      # Symbolized initial attribute method name
       #
-      # @return [Symbol] Attribute normalized name
+      # @return [Symbol] Attribute normalized method name
       #
-      def key
-        @key ||= prepare_key
+      def method_name
+        @method_name ||= prepare_method_name
       end
 
       #
@@ -97,8 +97,8 @@ class Serega
       # - plugin :formatters (wraps resulted block in formatter block and formats :const values)
       #
       def prepare_value_block
-        init_block ||
-          init_opts[:value] ||
+        prepare_init_block ||
+          prepare_value_option_block ||
           prepare_const_block ||
           prepare_delegate_block ||
           prepare_keyword_block
@@ -121,9 +121,8 @@ class Serega
         init_opts[:serializer]
       end
 
-      def prepare_key
-        key = init_opts[:key]
-        key ? key.to_sym : name
+      def prepare_method_name
+        (init_opts[:method] || init_name).to_sym
       end
 
       def prepare_const_block
@@ -134,17 +133,36 @@ class Serega
       end
 
       def prepare_keyword_block
-        key_method_name = key
+        key_method_name = method_name
         proc do |object|
           object.public_send(key_method_name)
         end
       end
 
+      def prepare_init_block
+        prepare_callable_proc(init_block)
+      end
+
+      def prepare_value_option_block
+        prepare_callable_proc(init_opts[:value])
+      end
+
+      def prepare_callable_proc(callable)
+        return unless callable
+
+        params_count = SeregaUtils::ParamsCount.call(callable, max_count: 2)
+        case params_count
+        when 0 then proc { |obj, _ctx| callable.call }
+        when 1 then proc { |obj, _ctx| callable.call(obj) }
+        else callable
+        end
+      end
+
       def prepare_delegate_block
         delegate = init_opts[:delegate]
         return unless delegate
 
-        key_method_name = delegate[:key] || key
+        key_method_name = delegate[:method] || method_name
         delegate_to = delegate[:to]
 
         allow_nil = delegate.fetch(:allow_nil) { self.class.serializer_class.config.delegate_default_allow_nil }

data/lib/serega/config.rb

@@ -15,7 +15,7 @@ class Serega
     DEFAULTS = {
       plugins: [],
       initiate_keys: %i[only with except check_initiate_params].freeze,
-      attribute_keys: %i[key value serializer many hide const delegate].freeze,
+      attribute_keys: %i[method value serializer many hide const delegate].freeze,
       serialize_keys: %i[context many].freeze,
       check_attribute_name: true,
       check_initiate_params: true,

data/lib/serega/object_serializer.rb

@@ -14,7 +14,7 @@ class Serega
 
       # @param plan [SeregaPlan] Serialization plan
       # @param context [Hash] Serialization context
-      # @param many [TrueClass|FalseClass] is object is enumerable
+      # @param many [Boolean] is object is enumerable
       # @param opts [Hash] Any custom options
       #
       # @return [SeregaObjectSerializer] New SeregaObjectSerializer

data/lib/serega/plan.rb

@@ -22,7 +22,7 @@ class Serega
       #
       def call(opts)
         max_cache_size = serializer_class.config.max_cached_plans_per_serializer_count
-        return new(opts) if max_cache_size.zero?
+        return new(nil, opts) if max_cache_size.zero?
 
         cached_plan_for(opts, max_cache_size)
       end
@@ -33,7 +33,7 @@ class Serega
         @cache ||= {}
         cache_key = construct_cache_key(opts)
 
-        plan = @cache[cache_key] ||= new(opts)
+        plan = @cache[cache_key] ||= new(nil, opts)
         @cache.shift if @cache.length > max_cache_size
         plan
       end
@@ -61,25 +61,26 @@ class Serega
       # @return [SeregaPlanPoint, nil]
       attr_reader :parent_plan_point
 
-      # Sets new parent plan point
-      # @return [SeregaPlanPoint] new parent plan point
-      attr_writer :parent_plan_point
-
       # Serialization points
       # @return [Array<SeregaPlanPoint>] points to serialize
       attr_reader :points
 
       #
-      # Instantiate new serialization plan.
+      # Instantiate new serialization plan
+      #
+      # Patched by
+      #  - depth_limit plugin, which checks depth limit is not exceeded when adding new plan
       #
-      # @param modifiers Serialization parameters
+      # @param parent_plan_point [SeregaPlanPoint, nil] Parent plan_point
+      # @param modifiers [Hash] Serialization parameters
       # @option modifiers [Hash] :only The only attributes to serialize
       # @option modifiers [Hash] :except Attributes to hide
       # @option modifiers [Hash] :with Hidden attributes to serialize additionally
       #
       # @return [SeregaPlan] Serialization plan
       #
-      def initialize(modifiers)
+      def initialize(parent_plan_point, modifiers)
+        @parent_plan_point = parent_plan_point
         @points = attributes_points(modifiers)
       end
 
@@ -107,8 +108,7 @@ class Serega
               {only: only[name], with: with[name], except: except[name]}
             end
 
-          point = serializer_class::SeregaPlanPoint.new(attribute, child_fields)
-          point.plan = self
+          point = serializer_class::SeregaPlanPoint.new(self, attribute, child_fields)
           points << point.freeze
         end
 

data/lib/serega/plan_point.rb

@@ -13,7 +13,7 @@ class Serega
 
       # Link to current plan this point belongs to
       # @return [SeregaAttribute] Current plan
-      attr_accessor :plan
+      attr_reader :plan
 
       # Shows current attribute
       # @return [SeregaAttribute] Current attribute
@@ -44,6 +44,7 @@ class Serega
       #
       # Initializes plan point
       #
+      # @param plan [SeregaPlan] Current plan this point belongs to
       # @param attribute [SeregaAttribute] Attribute to construct plan point
       # @param modifiers Serialization parameters
       # @option modifiers [Hash] :only The only attributes to serialize
@@ -52,7 +53,8 @@ class Serega
       #
       # @return [SeregaPlanPoint] New plan point
       #
-      def initialize(attribute, modifiers = nil)
+      def initialize(plan, attribute, modifiers = nil)
+        @plan = plan
         @attribute = attribute
         @modifiers = modifiers
         set_normalized_vars
@@ -79,9 +81,7 @@ class Serega
 
         fields = modifiers || FROZEN_EMPTY_HASH
 
-        plan = serializer::SeregaPlan.new(fields)
-        plan.parent_plan_point = self
-        plan
+        serializer::SeregaPlan.new(self, fields)
       end
     end
 

data/lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb

@@ -77,7 +77,7 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
-        require_relative "./lib/preloader"
+        require_relative "lib/preloader"
 
         serializer_class.include(InstanceMethods)
       end

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

@@ -79,18 +79,18 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
-        require_relative "./lib/batch_config"
-        require_relative "./lib/loader"
-        require_relative "./lib/loaders"
-        require_relative "./lib/modules/attribute"
-        require_relative "./lib/modules/attribute_normalizer"
-        require_relative "./lib/modules/check_attribute_params"
-        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_loader"
-        require_relative "./lib/validations/check_opt_batch"
+        require_relative "lib/batch_config"
+        require_relative "lib/loader"
+        require_relative "lib/loaders"
+        require_relative "lib/modules/attribute"
+        require_relative "lib/modules/attribute_normalizer"
+        require_relative "lib/modules/check_attribute_params"
+        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_loader"
+        require_relative "lib/validations/check_opt_batch"
 
         serializer_class.extend(ClassMethods)
         serializer_class.include(InstanceMethods)
@@ -121,18 +121,18 @@ class Serega
         serializer_class.const_set(:SeregaBatchLoader, batch_loader_class)
 
         if serializer_class.plugin_used?(:activerecord_preloads)
-          require_relative "./lib/plugins_extensions/activerecord_preloads"
+          require_relative "lib/plugins_extensions/activerecord_preloads"
           serializer_class::SeregaBatchLoader.include(PluginsExtensions::ActiveRecordPreloads::BatchLoaderInstanceMethods)
         end
 
         if serializer_class.plugin_used?(:formatters)
-          require_relative "./lib/plugins_extensions/formatters"
+          require_relative "lib/plugins_extensions/formatters"
           serializer_class::SeregaBatchLoader.include(PluginsExtensions::Formatters::BatchLoaderInstanceMethods)
           serializer_class::SeregaAttribute.include(PluginsExtensions::Formatters::SeregaAttributeInstanceMethods)
         end
 
         if serializer_class.plugin_used?(:preloads)
-          require_relative "./lib/plugins_extensions/preloads"
+          require_relative "lib/plugins_extensions/preloads"
           serializer_class::SeregaAttributeNormalizer.include(PluginsExtensions::Preloads::AttributeNormalizerInstanceMethods)
         end
 

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

@@ -22,17 +22,20 @@ class Serega
         #
         # @return [void]
         #
-        def define(loader_name, &block)
-          unless block
-            raise SeregaError, "Block must be given to #define method"
+        def define(loader_name, callable = nil, &block)
+          if (!callable && !block) || (callable && block)
+            raise SeregaError, "Batch loader can be specified with one of arguments - callable value or &block"
           end
 
-          params = block.parameters
-          if params.count > 3 || !params.all? { |param| (param[0] == :req) || (param[0] == :opt) }
-            raise SeregaError, "Block can have maximum 3 regular parameters"
+          callable ||= block
+          SeregaValidations::Utils::CheckExtraKeywordArg.call(callable, "batch loader `#{loader_name}`")
+          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)"
           end
 
-          loaders[loader_name] = block
+          loaders[loader_name] = callable
         end
 
         # Shows defined loaders
@@ -48,7 +51,7 @@ class Serega
         #
         # @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, ctx, points| ... }")
+          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

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

@@ -42,22 +42,37 @@ class Serega
           batch = init_opts[:batch]
           return unless batch
 
-          # take loader
-          loader = batch[:loader]
+          loader = prepare_batch_loader(batch[:loader])
 
-          # take key
           key = batch[:key] || self.class.serializer_class.config.batch.default_key
-          proc_key =
-            if key.is_a?(Symbol)
-              proc { |object| object.public_send(key) }
-            else
-              key
-            end
+          key = prepare_batch_key(key)
 
-          # take default value
           default = batch.fetch(:default) { many ? FROZEN_EMPTY_ARRAY : nil }
 
-          {loader: loader, key: proc_key, default: default}
+          {loader: loader, key: key, default: default}
+        end
+
+        def prepare_batch_key(key)
+          return proc { |object| object.public_send(key) } if key.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(key, max_count: 2)
+          case params_count
+          when 0 then proc { key.call }
+          when 1 then proc { |object| key.call(object) }
+          else key
+          end
+        end
+
+        def prepare_batch_loader(loader)
+          return loader if loader.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
+          case params_count
+          when 0 then proc { loader.call }
+          when 1 then proc { |object| loader.call(object) }
+          when 2 then proc { |object, context| loader.call(object, context) }
+          else loader
+          end
         end
       end
     end