ree_lib 1.0.86 → 1.0.88

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/benchmarks/mapper_benchmark_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'benchmark'
+
+package_require "ree_mapper"
+
+RSpec.xdescribe 'Mapper Benchmark' do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper) do
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast, dto: Hash),
+      ]
+    ).call.use(:cast) do
+      hash :my_field do
+        hash :my_field do
+          integer :my_field
+        end
+      end
+    end
+  end
+
+  it do
+    obj = { my_field: { my_field: { my_field: 1 } } }
+
+    _benchmark_res = Benchmark.bmbm do |x|
+      x.report('cast') { 1000.times { mapper.cast(obj) } }
+    end
+  end
+end

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/bool_spec.rb

@@ -31,11 +31,11 @@ RSpec.describe 'ReeMapper::Bool' do
     }
 
     it {
-      expect { mapper.serialize({ bool: 'true' }) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean, got `\"true\"`")
+      expect { mapper.serialize({ bool: 'true' }) }.to raise_error(ReeMapper::TypeError, /`bool` should be a boolean, got `\"true\"`/)
     }
 
     it {
-      expect { mapper.serialize({ bool: 1 }) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean, got `1`")
+      expect { mapper.serialize({ bool: 1 }) }.to raise_error(ReeMapper::TypeError, /`bool` should be a boolean, got `1`/)
     }
   end
 
@@ -81,12 +81,12 @@ RSpec.describe 'ReeMapper::Bool' do
     }
 
     it {
-      expect { mapper.cast({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean, got `\"right\"`")
+      expect { mapper.cast({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError, /`bool` is invalid boolean, got `\"right\"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.cast({ 'bool' => object }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean, got `#{object.inspect}`")
+      expect { mapper.cast({ 'bool' => object }) }.to raise_error(ReeMapper::CoercionError, /`bool` is invalid boolean, got `#{object.inspect}`/)
     }
   end
 
@@ -100,11 +100,11 @@ RSpec.describe 'ReeMapper::Bool' do
     }
 
     it {
-      expect { mapper.db_dump(OpenStruct.new({ bool: 'true' })) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean, got `\"true\"`")
+      expect { mapper.db_dump(OpenStruct.new({ bool: 'true' })) }.to raise_error(ReeMapper::TypeError, /`bool` should be a boolean, got `\"true\"`/)
     }
 
     it {
-      expect { mapper.db_dump(OpenStruct.new({ bool: 1 })) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean, got `1`")
+      expect { mapper.db_dump(OpenStruct.new({ bool: 1 })) }.to raise_error(ReeMapper::TypeError, /`bool` should be a boolean, got `1`/)
     }
   end
 
@@ -150,12 +150,12 @@ RSpec.describe 'ReeMapper::Bool' do
     }
 
     it {
-      expect { mapper.db_load({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean, got `\"right\"`")
+      expect { mapper.db_load({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError, /`bool` is invalid boolean, got `\"right\"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_load({ 'bool' => object }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean, got `#{object.inspect}`")
+      expect { mapper.db_load({ 'bool' => object }) }.to raise_error(ReeMapper::CoercionError, /`bool` is invalid boolean, got `#{object.inspect}`/)
     }
   end
 end