ree_lib 1.0.92 → 1.0.94

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/any.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 class ReeMapper::Any < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
-  def serialize(value, name:, location: nil)
+  contract(Any => Any)
+  def serialize(value)
     value
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
-  def cast(value, name:, location: nil)
+  contract(Any => Any)
+  def cast(value)
     value
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
-  def db_dump(value, name:, location: nil)
+  contract(Any => Any)
+  def db_dump(value)
     value
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
-  def db_load(value, name:, location: nil)
+  contract(Any => Any)
+  def db_load(value)
     value
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/bool.rb

@@ -4,33 +4,33 @@ class ReeMapper::Bool < ReeMapper::AbstractType
   TRUE_CAST_VALUES = ['1', 'true', 'on', 1, true].freeze
   FALSE_CAST_VALUES = ['0', 'false', 'off', 0, false].freeze
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => Bool).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.is_a?(TrueClass) || value.is_a?(FalseClass)
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a boolean, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a boolean, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::CoercionError)
-  def cast(value, name:, location: nil)
+  contract(Any => Bool).throws(ReeMapper::CoercionError)
+  def cast(value)
     if TRUE_CAST_VALUES.include?(value)
       true
     elsif FALSE_CAST_VALUES.include?(value)
       false
     else
-      raise ReeMapper::CoercionError.new("`#{name}` is invalid boolean, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::CoercionError.new("is invalid boolean, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => Bool)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::CoercionError)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => Bool)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date.rb

@@ -3,17 +3,17 @@
 require 'date'
 
 class ReeMapper::Date < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => Date).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.class == Date
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a date, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a date, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def cast(value, name:, location: nil)
+  contract(Any => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def cast(value)
     if value.class == Date
       value
     elsif value.class == DateTime || value.class == Time
@@ -21,21 +21,21 @@ class ReeMapper::Date < ReeMapper::AbstractType
     elsif value.is_a?(String)
       begin
         Date.parse(value)
-      rescue ArgumentError => e
-        raise ReeMapper::CoercionError.new("`#{name}` is invalid date, got `#{truncate(value.inspect)}`", location)
+      rescue ArgumentError
+        raise ReeMapper::CoercionError.new("is invalid date, got `#{truncate(value.inspect)}`")
       end
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a date, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a date, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => Date).throws(ReeMapper::TypeError)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date_time.rb

@@ -3,17 +3,17 @@
 require 'date'
 
 class ReeMapper::DateTime < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => DateTime).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.class == DateTime
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a datetime, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a datetime, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, location: nil)
+  contract(Any => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value)
     if value.class == DateTime
       value
     elsif value.class == Time
@@ -22,20 +22,20 @@ class ReeMapper::DateTime < ReeMapper::AbstractType
       begin
         ReeDatetime::InDefaultTimeZone.new.call(DateTime.parse(value))
       rescue ArgumentError
-        raise ReeMapper::CoercionError.new("`#{name}` is invalid datetime, got `#{truncate(value.inspect)}`", location)
+        raise ReeMapper::CoercionError.new("is invalid datetime, got `#{truncate(value.inspect)}`")
       end
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a datetime, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a datetime, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => DateTime)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => DateTime)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/float.rb

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
 class ReeMapper::Float < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => Float).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.is_a?(Float)
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a float, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a float, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, location: nil)
+  contract(Any => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value)
     if value.is_a?(Numeric)
       value.to_f
     elsif value.is_a?(String)
       begin
         Float(value)
-      rescue ArgumentError => e
-        raise ReeMapper::CoercionError.new("`#{name}` is invalid float, got `#{truncate(value.inspect)}`", location)
+      rescue ArgumentError
+        raise ReeMapper::CoercionError.new("is invalid float, got `#{truncate(value.inspect)}`")
       end
     elsif defined?(BigDecimal) && value.is_a?(BigDecimal)
       value.to_f
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a float, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a float, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => Float).throws(ReeMapper::CoercionError)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/integer.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
 class ReeMapper::Integer < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => Integer).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.is_a? Integer
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be an integer, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be an integer, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, location: nil)
+  contract(Any => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value)
     if value.is_a?(Integer)
       value
     elsif value.is_a?(String)
       coerced_value = Integer(value, exception: false)
       if coerced_value.nil?
-        raise ReeMapper::CoercionError.new("`#{name}` is invalid integer, got `#{truncate(value.inspect)}`", location)
+        raise ReeMapper::CoercionError.new("is invalid integer, got `#{truncate(value.inspect)}`")
       end
       coerced_value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be an integer, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be an integer, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => Integer).throws(ReeMapper::TypeError)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/rational.rb

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
 class ReeMapper::Rational < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => Rational).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.is_a?(Rational)
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a rational, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a rational, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, location: nil)
+  contract(Any => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value)
     if value.is_a?(Rational)
       value
     elsif value.is_a?(String)
       begin
         Rational(value)
-      rescue ArgumentError, ZeroDivisionError => e
-        raise ReeMapper::CoercionError.new("`#{name}` is invalid rational, got `#{truncate(value.inspect)}`", location)
+      rescue ArgumentError, ZeroDivisionError
+        raise ReeMapper::CoercionError.new("is invalid rational, got `#{truncate(value.inspect)}`")
       end
     elsif value.is_a?(Numeric)
       Rational(value)
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a rational, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a rational, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => String)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location).to_s
+  contract(Any => String)
+  def db_dump(value)
+    serialize(value).to_s
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => Rational)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/string.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
 class ReeMapper::String < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => String).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.is_a? String
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a string, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a string, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
-  def cast(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => String).throws(ReeMapper::TypeError)
+  def cast(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => String).throws(ReeMapper::TypeError)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
-  def db_load(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => String).throws(ReeMapper::TypeError)
+  def db_load(value)
+    serialize(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/time.rb

@@ -3,17 +3,17 @@
 require 'time'
 
 class ReeMapper::Time < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::TypeError)
-  def serialize(value, name:, location: nil)
+  contract(Any => Time).throws(ReeMapper::TypeError)
+  def serialize(value)
     if value.class == Time
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a time, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a time, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, location: nil)
+  contract(Any => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value)
     if value.class == Time
       value
     elsif value.class == DateTime
@@ -22,20 +22,20 @@ class ReeMapper::Time < ReeMapper::AbstractType
       begin
         Time.parse(value)
       rescue ArgumentError
-        raise ReeMapper::CoercionError.new("`#{name}` is invalid time, got `#{truncate(value.inspect)}`", location)
+        raise ReeMapper::CoercionError.new("is invalid time, got `#{truncate(value.inspect)}`")
       end
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a time, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a time, got `#{truncate(value.inspect)}`")
     end
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, location: nil)
-    serialize(value, name: name, location: location)
+  contract(Any => Time).throws(ReeMapper::TypeError)
+  def db_dump(value)
+    serialize(value)
   end
 
-  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, location: nil)
-    cast(value, name: name, location: location)
+  contract(Any => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value)
+    cast(value)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/wrappers/array.rb

@@ -4,116 +4,124 @@ class ReeMapper::Array < ReeMapper::AbstractWrapper
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Array
   ).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil, fields_filters: [], location: nil)
-    if value.is_a?(Array)
-      value.map.with_index {
-        if _1.nil? && subject.null
-          _1
-        else
-          subject.type.serialize(
-            _1, 
-            name: "#{name}[#{_2}]", 
-            role: role, 
-            fields_filters: fields_filters + [subject.fields_filter],
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def serialize(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.serialize(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Array
   ).throws(ReeMapper::TypeError)
-  def cast(value, name:, role: nil, fields_filters: [], location: nil)
-    if value.is_a?(Array)
-      value.map.with_index {
-        if _1.nil? && subject.null
-          _1
-        else
-          subject.type.cast(
-            _1, 
-            name: "#{name}[#{_2}]", 
-            role: role, 
-            fields_filters: fields_filters + [subject.fields_filter],
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def cast(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.cast(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Array
   ).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil, fields_filters: [], location: nil)
-    if value.is_a?(Array)
-      value.map.with_index {
-        if _1.nil? && subject.null
-          _1
-        else
-          subject.type.db_dump(
-            _1, 
-            name: "#{name}[#{_2}]", 
-            role: role, 
-            fields_filters: fields_filters + [subject.fields_filter],
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def db_dump(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.db_dump(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Array
   ).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [], location: nil)
-    if value.is_a?(Array)
-      value.map.with_index {
-        if _1.nil? && subject.null
-          _1
-        else
-          subject.type.db_load(
-            _1, 
-            name: "#{name}[#{_2}]", 
-            role: role, 
-            fields_filters: fields_filters + [subject.fields_filter], 
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def db_load(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.db_load(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 end