ree_lib 1.0.86 → 1.0.87

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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a?(TrueClass) || value.is_a?(FalseClass)
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a boolean, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a boolean, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::CoercionError)
+  def cast(value, name:, location: nil)
     if TRUE_CAST_VALUES.include?(value)
       true
     elsif FALSE_CAST_VALUES.include?(value)
       false
     else
-      raise ReeMapper::CoercionError, "`#{name}` is invalid boolean, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::CoercionError.new("`#{name}` is invalid boolean, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  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)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.class == Date
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a date, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a date, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def cast(value, name:, location: nil)
     if value.class == Date
       value
     elsif value.class == DateTime || value.class == Time
@@ -22,20 +22,20 @@ class ReeMapper::Date < ReeMapper::AbstractType
       begin
         Date.parse(value)
       rescue ArgumentError => e
-        raise ReeMapper::CoercionError, "`#{name}` is invalid date, got `#{truncate(value.inspect)}`"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid date, got `#{truncate(value.inspect)}`", location)
       end
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a date, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a date, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  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)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.class == DateTime
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a datetime, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a datetime, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     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, "`#{name}` is invalid datetime, got `#{truncate(value.inspect)}`"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid datetime, got `#{truncate(value.inspect)}`", location)
       end
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a datetime, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a datetime, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  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)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a?(Float)
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a float, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a float, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     if value.is_a?(Numeric)
       value.to_f
     elsif value.is_a?(String)
       begin
         Float(value)
       rescue ArgumentError => e
-        raise ReeMapper::CoercionError, "`#{name}` is invalid float, got `#{truncate(value.inspect)}`"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid float, got `#{truncate(value.inspect)}`", location)
       end
     elsif defined?(BigDecimal) && value.is_a?(BigDecimal)
       value.to_f
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a float, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a float, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  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)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a? Integer
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an integer, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an integer, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]]=> Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     if value.is_a?(Integer)
       value
     elsif value.is_a?(String)
       coerced_value = Integer(value, exception: false)
       if coerced_value.nil?
-        raise ReeMapper::CoercionError, "`#{name}` is invalid integer, got `#{truncate(value.inspect)}`"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid integer, got `#{truncate(value.inspect)}`", location)
       end
       coerced_value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an integer, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an integer, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  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)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a?(Rational)
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a rational, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a rational, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     if value.is_a?(Rational)
       value
     elsif value.is_a?(String)
       begin
         Rational(value)
       rescue ArgumentError, ZeroDivisionError => e
-        raise ReeMapper::CoercionError, "`#{name}` is invalid rational, got `#{truncate(value.inspect)}`"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid rational, got `#{truncate(value.inspect)}`", location)
       end
     elsif value.is_a?(Numeric)
       Rational(value)
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a rational, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a rational, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role).to_s
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location).to_s
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a? String
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a string, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a string, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.class == Time
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a time, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a time, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     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, "`#{name}` is invalid time, got `#{truncate(value.inspect)}`"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid time, got `#{truncate(value.inspect)}`", location)
       end
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a time, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a time, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role)
+  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)
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  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)
   end
 end

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

@@ -1,67 +1,119 @@
 # frozen_string_literal: true
 
 class ReeMapper::Array < ReeMapper::AbstractWrapper
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => 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])
+          subject.type.serialize(
+            _1, 
+            name: "#{name}[#{_2}]", 
+            role: role, 
+            fields_filters: fields_filters + [subject.fields_filter],
+            location: subject.location,
+          )
         end
       }
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an array, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def cast(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => 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])
+          subject.type.cast(
+            _1, 
+            name: "#{name}[#{_2}]", 
+            role: role, 
+            fields_filters: fields_filters + [subject.fields_filter],
+            location: subject.location,
+          )
         end
       }
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an array, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => 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])
+          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, "`#{name}` should be an array, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => 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])
+          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, "`#{name}` should be an array, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
-end
+end

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

@@ -14,6 +14,7 @@ module ReeMapper
 
   require_relative 'ree_mapper/types/abstract_type'
   require_relative 'ree_mapper/errors/error'
+  require_relative 'ree_mapper/errors/error_with_location'
   require_relative 'ree_mapper/errors/coercion_error'
   require_relative 'ree_mapper/errors/type_error'
   require_relative 'ree_mapper/errors/unsupported_type_error'

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_factory_spec.rb

@@ -82,10 +82,12 @@ RSpec.describe ReeMapper::MapperFactory do
   describe '.register_wrapper' do
     let(:round_wrapper) {
       Class.new(ReeMapper::AbstractWrapper) do
-        def serialize(value, name:, **opts)
-          raise ReeMapper::TypeError, "`#{name}` should be a number, got `#{truncate(value.inspect)}`" if !value.is_a?(Numeric)
+        def serialize(value, name:, location: nil, **opts)
+          if !value.is_a?(Numeric)
+            raise ReeMapper::TypeError.new("`#{name}` should be a number, got `#{truncate(value.inspect)}`", location)
+          end
 
-          subject.type.serialize(value.round, name: name, **opts)
+          subject.type.serialize(value.round, name: name, location: subject.location, **opts)
         end
       end
     }
@@ -100,10 +102,12 @@ RSpec.describe ReeMapper::MapperFactory do
 
     it 'allow to register caster and serializer with the same name' do
       caster_round_wrapper = Class.new(ReeMapper::AbstractWrapper) do
-        def cast(value, name:, **opts)
-          value = subject.type.cast(value, name: name, **opts)
+        def cast(value, name:, location: nil, **opts)
+          value = subject.type.cast(value, name: name, location: subject.location, **opts)
 
-          raise ReeMapper::TypeError, "`#{name}` should be a number, got `#{truncate(value.inspect)}`" if !value.is_a?(Numeric)
+          if !value.is_a?(Numeric)
+            raise ReeMapper::TypeError.new("`#{name}` should be a number, got `#{truncate(value.inspect)}`", location)
+          end
           value.round
         end
       end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+package_require "ree_mapper"
 
 RSpec.describe ReeMapper::Mapper do
   link :build_mapper_factory, from: :ree_mapper
@@ -32,6 +33,12 @@ RSpec.describe ReeMapper::Mapper do
       obj.define_singleton_method(:my_field) { 1 }
       expect(mapper.cast(obj)).to eq({ my_field: 1 })
     }
+
+    it "add mapper location to error full message" do
+      mapper.cast({ my_field: "not number" })
+    rescue => e
+      expect(e.full_message).to include("located at")
+    end
   end
 
   describe 'hash dto' do

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/time_spec.rb

@@ -93,7 +93,8 @@ RSpec.describe 'ReeMapper::Time' do
     }
 
     it {
-      expect { mapper.db_dump({ time: Time.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `\"2020-01-01 00:00:00 +0000\"`")
+      time = Time.new(2020).to_s
+      expect { mapper.db_dump({ time: time }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{time.inspect}`")
     }
 
     it {

data/lib/ree_lib/spec.init.rb

@@ -11,4 +11,6 @@ Bootsnap.setup(
 require 'rspec'
 require 'ree'
 
-Ree.init(__dir__)
+ENV["RUBY_ENV"] = "test"
+
+Ree.init(__dir__)

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.86"
+  VERSION = "1.0.87"
 end