ree_lib 1.0.86 → 1.0.88

data/lib/ree_lib/packages/ree_http/spec/ree_http/functions/http_get_spec.rb

@@ -38,7 +38,7 @@ RSpec.describe :http_get do
 
       http_get(
         host,
-        basic_auth: {username: 'user', password: 'pass'}
+        basic_auth: { username: 'user', password: 'pass' }
       )
       expect(WebMock).to have_requested(:get, host).with(basic_auth: ['user', 'pass'])
 
@@ -50,20 +50,20 @@ RSpec.describe :http_get do
 
       http_get(
         host,
-        query_params: { q: 100, "s"=> 'simple'}
+        query_params: { q: 100, "s"=> 'simple' }
       )
-      expect(WebMock).to have_requested(:get, host).with(query: { "q"=> 100, "s"=> "simple"})
+      expect(WebMock).to have_requested(:get, host).with(query: { "q"=> 100, "s"=> "simple" })
 
       http_get(
         host_with_path + '?a=200',
-        query_params: { q: 100, "s"=> 'simple'}
+        query_params: { q: 100, "s"=> 'simple' }
       )
-      expect(WebMock).to have_requested(:get, host_with_path).with(query: {"a"=>200, "q"=> 100, "s"=> "simple"})
+
+      expect(WebMock).to have_requested(:get, host_with_path).with(query: { "a"=>200, "q"=> 100, "s"=> "simple" })
     end
   end
 
   context "force ssl" do
-
     before :all do
       WebMock.reset!
       WebMock
@@ -84,6 +84,7 @@ RSpec.describe :http_get do
         host,
         force_ssl: true, headers: { token: '321'}
       )
+
       expect(WebMock).to have_requested(:get, host_with_ssl).with(headers: { 'Token'=>'321' })
     end
   end
@@ -100,7 +101,7 @@ RSpec.describe :http_get do
             'User-Agent'=>'Ruby',
           }
         )
-        .to_return(status: 307, headers: {'Location': 'https://www.example.com/'})
+        .to_return(status: 307, headers: { 'Location': 'https://www.example.com/' })
 
       WebMock
         .stub_request(:get, 'https://www.example.com/redirect_303')
@@ -111,7 +112,51 @@ RSpec.describe :http_get do
             'User-Agent'=>'Ruby',
           }
         )
-        .to_return(status: 303, headers: {'Location': 'https://www.example.com/'})
+        .to_return(status: 303, headers: { 'Location': 'https://www.example.com/' })
+
+      WebMock
+        .stub_request(:any, 'https://domain.com')
+        .with(
+          headers: {
+            'Accept'=>'*/*',
+            'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent'=>'Ruby',
+          }
+        )
+        .to_return(status: 302, headers: { 'Location': 'https://www.domain.com' })
+
+      WebMock
+        .stub_request(:any, 'https://www.domain.com')
+        .with(
+          headers: {
+            'Accept'=>'*/*',
+            'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent'=>'Ruby',
+          }
+        )
+        .to_return(status: 200, headers: {})
+
+      WebMock
+        .stub_request(:any, 'https://www.anotherdomain.com')
+        .with(
+          headers: {
+            'Accept'=>'*/*',
+            'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent'=>'Ruby',
+          }
+        )
+        .to_return(status: 302, headers: { 'Location': 'https://sub.anotherdomain.com' })
+
+      WebMock
+        .stub_request(:any, 'https://sub.anotherdomain.com')
+        .with(
+          headers: {
+            'Accept'=>'*/*',
+            'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent'=>'Ruby',
+          }
+        )
+        .to_return(status: 200, headers: {})
 
       WebMock
         .stub_request(:any, 'https://www.example.com/redirect_303_infinity')
@@ -122,7 +167,7 @@ RSpec.describe :http_get do
             'User-Agent'=>'Ruby',
           }
         )
-        .to_return(status: 303, headers: {'Location': 'https://www.example.com/redirect_303_infinity'})
+        .to_return(status: 303, headers: { 'Location': 'https://www.example.com/redirect_303_infinity' })
 
       WebMock
         .stub_request(:any, 'https://www.example.com/')
@@ -130,36 +175,52 @@ RSpec.describe :http_get do
           headers: {
             'Accept'=>'*/*',
             'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-            'User-Agent'=>'Ruby',
-            'Token'=>'123'
+            'Host' => 'www.example.com',
+            'User-Agent'=>'Ruby'
           }
         )
-        .to_return(status: 200, headers: {'Token': '123'})
+        .to_return(status: 200, headers: { 'Token': '123' })
     end
+
     after :all do
       WebMock.reset!
     end
+
     include ReeHttp::HttpExceptions
+
     let(:err_result) {
       http_get(
-        host_with_ssl + '/redirect_303_infinity',
+        'https://www.example.com/redirect_303_infinity',
         force_ssl: true, headers: { token: '123'}
       )
     }
 
     it do
-      expect{err_result}.to raise_error(ReeHttp::HttpExceptions::TooManyRedirectsError)
+      expect{ err_result }.to raise_error(ReeHttp::HttpExceptions::TooManyRedirectsError)
 
       http_get(
-        host_with_ssl + '/redirect_307',
-        force_ssl: true, headers: { token: '123'}
+        "https://domain.com",
+        force_ssl: true
       )
 
+      expect(WebMock).to have_requested(:get, "https://domain.com").once
+      expect(WebMock).to have_requested(:get, "https://www.domain.com").once
+
       http_get(
-        host_with_ssl + '/redirect_303',
+        "https://www.anotherdomain.com",
+        force_ssl: true
+      )
+
+      expect(WebMock).to have_requested(:get, "https://www.anotherdomain.com").once
+      expect(WebMock).to have_requested(:get, "https://sub.anotherdomain.com").once
+
+      http_get(
+        host_with_ssl + '/redirect_307',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:get, host_with_ssl).with(headers: { 'Token'=>'123' }).twice
+
+      expect(WebMock).to have_requested(:get, 'https://www.example.com/redirect_307').with(headers: { token: '123'}).once
+      expect(WebMock).to have_requested(:get, 'https://www.example.com').once
     end
   end
 end

data/lib/ree_lib/packages/ree_http/spec/ree_http/functions/http_options_spec.rb

@@ -148,10 +148,10 @@ RSpec.describe :http_options do
             'Accept'=>'*/*',
             'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
             'User-Agent'=>'Ruby',
-            'Token'=>'123'
+            'Host' => 'www.example.com'
           }
         )
-        .to_return(status: 200, headers: {'Token': '123'})
+        .to_return(status: 200)
     end
     after :all do
       WebMock.reset!
@@ -171,14 +171,15 @@ RSpec.describe :http_options do
         host_with_ssl + '/redirect_307',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:options, host_with_ssl).with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:options, host_with_ssl + '/redirect_307').with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:options, host_with_ssl).once
 
       http_options(
         host_with_ssl + '/redirect_303',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:get, host_with_ssl).with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:options, host_with_ssl + '/redirect_303').with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:get, host_with_ssl).once
     end
   end
 end
-

data/lib/ree_lib/packages/ree_http/spec/ree_http/functions/http_patch_spec.rb

@@ -141,10 +141,10 @@ RSpec.describe :http_patch do
             'Accept'=>'*/*',
             'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
             'User-Agent'=>'Ruby',
-            'Token'=>'123'
+            'Host' => 'www.example.com'
           }
         )
-        .to_return(status: 200, headers: {'Token': '123'})
+        .to_return(status: 200)
     end
     after :all do
       WebMock.reset!
@@ -164,13 +164,17 @@ RSpec.describe :http_patch do
         host_with_ssl + '/redirect_307',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:patch, host_with_ssl).with(headers: { 'Token'=>'123' })
+
+      expect(WebMock).to have_requested(:patch, host_with_ssl + '/redirect_307').with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:patch, host_with_ssl).once
 
       http_patch(
         host_with_ssl + '/redirect_303',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:get, host_with_ssl).with(headers: { 'Token'=>'123' })
+
+      expect(WebMock).to have_requested(:patch, host_with_ssl + '/redirect_303').with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:get, host_with_ssl).once
     end
   end
 end

data/lib/ree_lib/packages/ree_http/spec/ree_http/functions/http_post_spec.rb

@@ -90,13 +90,6 @@ RSpec.describe :http_post do
       ensure
         tempfile&.close!
       end
-
-      # works !
-      # response = http_post(
-      #   'http://127.0.0.1:8085/end',
-      #   query_params: { q: 100, "s"=> 'simple'},
-      #   form_data: {arg: "abc"}
-      # )
     end
   end
 
@@ -169,7 +162,7 @@ RSpec.describe :http_post do
             'Accept'=>'*/*',
             'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
             'User-Agent'=>'Ruby',
-            'Token'=>'123'
+            'Host'=>'www.example.com'
           }
         )
         .to_return(status: 200, headers: {'Token': '123'})
@@ -192,13 +185,15 @@ RSpec.describe :http_post do
         host_with_ssl + '/redirect_307',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:post, host_with_ssl).with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:post, host_with_ssl + "/redirect_307").with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:post, host_with_ssl).once
 
       http_post(
         host_with_ssl + '/redirect_303',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:get, host_with_ssl).with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:post, host_with_ssl + "/redirect_303").with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:get, host_with_ssl).once
     end
   end
 end

data/lib/ree_lib/packages/ree_http/spec/ree_http/functions/http_put_spec.rb

@@ -141,7 +141,7 @@ RSpec.describe :http_put do
             'Accept'=>'*/*',
             'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
             'User-Agent'=>'Ruby',
-            'Token'=>'123'
+            'Host' => 'www.example.com'
           }
         )
         .to_return(status: 200, headers: {'Token': '123'})
@@ -164,13 +164,15 @@ RSpec.describe :http_put do
         host_with_ssl + '/redirect_307',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:put, host_with_ssl).with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:put, host_with_ssl + '/redirect_307').with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:put, host_with_ssl).once
 
       http_put(
         host_with_ssl + '/redirect_303',
         force_ssl: true, headers: { token: '123'}
       )
-      expect(WebMock).to have_requested(:get, host_with_ssl).with(headers: { 'Token'=>'123' })
+      expect(WebMock).to have_requested(:put, host_with_ssl + '/redirect_303').with(headers: { 'Token'=>'123' }).once
+      expect(WebMock).to have_requested(:get, host_with_ssl).once
     end
   end
 end

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

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-class ReeMapper::CoercionError < ReeMapper::Error
+class ReeMapper::CoercionError < ReeMapper::ErrorWithLocation
 end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ReeMapper::ErrorWithLocation < ReeMapper::Error
+  attr_reader :location
+
+  def initialize(message, location = nil)
+    if message.is_a?(String) && location && ENV["RUBY_ENV"] == "test"
+      message = "#{message}, located at #{location}"
+    end
+
+    super(message)
+    @location = location
+  end
+
+  def full_message(...)
+    msg = super
+    return msg if location.nil?
+
+    idx = msg.index(/\).*\n/)
+    return msg if idx.nil?
+    return msg if ENV["RUBY_ENV"] == "test"
+
+    msg.insert(idx + 1, ", located at #{location}")
+  end
+end

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

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-class ReeMapper::TypeError < ReeMapper::Error
+class ReeMapper::TypeError < ReeMapper::ErrorWithLocation
 end

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

@@ -3,7 +3,7 @@
 class ReeMapper::Field
   attr_reader :type, :name, :from, :doc, :optional, :null, :roles, :default,
               :name_as_str, :name_as_instance_var_name, :from_as_str,
-              :fields_filter
+              :fields_filter, :location
 
   NO_DEFAULT = Object.new.freeze
 
@@ -18,11 +18,12 @@ class ReeMapper::Field
       role:     Nilor[ArrayOf[Symbol], Symbol],
       default:  Any,
       only:     Nilor[ReeMapper::FilterFieldsContract],
-      except:   Nilor[ReeMapper::FilterFieldsContract]
+      except:   Nilor[ReeMapper::FilterFieldsContract],
+      location: Nilor[String],
     ] => Any
   ).throws(ArgumentError)
-  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT, 
-                 only: nil, except: nil)
+  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT,
+                 only: nil, except: nil, location: nil)
     @type     = type
     @name     = name
     @from     = from || name
@@ -38,6 +39,13 @@ class ReeMapper::Field
     @name_as_instance_var_name = :"@#{@name}"
     @from_as_str               = @from.to_s
 
+    @location = location
+    if @location
+      @location = @location
+        .sub(Ree.root_dir, ".")
+        .sub(/:in.+/, "")
+    end
+
     raise ArgumentError, 'required fields do not support defaults' if has_default? && !optional
   end
 

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class ReeMapper::Mapper
+  EMPTY_ARY = [].freeze
+
   contract(
     ArrayOf[ReeMapper::MapperStrategy],
     Nilor[ReeMapper::AbstractType, ReeMapper::AbstractWrapper] => self
@@ -23,19 +25,19 @@ class ReeMapper::Mapper
 
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: [])
+            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: EMPTY_ARY, location: nil)
               #{
                 if type.is_a?(ReeMapper::AbstractWrapper)
-                  "@type.#{method}(obj, name: name, role: role, fields_filters: fields_filters)"
+                  "@type.#{method}(obj, name: name, role: role, fields_filters: fields_filters, location: location)"
                 else
-                  "@type.#{method}(obj, name: name, role: role)"
+                  "@type.#{method}(obj, name: name, location: location)"
                 end
               }
             end
           RUBY
         else
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: [])
+            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: EMPTY_ARY, location: nil)
               if only && !ReeMapper::FilterFieldsContract.valid?(only)
                 raise ReeMapper::ArgumentError, "Invalid `only` format"
               end
@@ -47,7 +49,11 @@ class ReeMapper::Mapper
               user_fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
 
               @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
-                field_fields_filters = fields_filters + [user_fields_filter]
+                field_fields_filters = if user_fields_filter == ReeMapper::FieldsFilter::NoneStrategy
+                  fields_filters
+                else
+                  fields_filters + [user_fields_filter]
+                end
 
                 next unless field_fields_filters.all? { _1.allow? field.name }
                 next unless field.has_role?(role)
@@ -56,7 +62,10 @@ class ReeMapper::Mapper
                 is_optional = field.optional || @#{method}_strategy.always_optional
 
                 if !is_with_value && !is_optional
-                  raise ReeMapper::TypeError, "Missing required field `\#{field.from_as_str}` for `\#{name || 'root'}`"
+                  raise ReeMapper::TypeError.new(
+                    "Missing required field `\#{field.from_as_str}` for `\#{name || 'root'}`", 
+                    field.location
+                  )
                 end
 
                 next if !is_with_value && !field.has_default?
@@ -70,10 +79,23 @@ class ReeMapper::Mapper
                 unless value.nil? && field.null
                   nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
 
-                  nested_fields_filters = field_fields_filters.map { _1.filter_for(field.name) }
-                  nested_fields_filters += [field.fields_filter]
-
-                  value = field.type.#{method}(value, name: nested_name, role: role, fields_filters: nested_fields_filters)
+                  nested_fields_filters = if field_fields_filters.empty?
+                    field_fields_filters
+                  else
+                    field_fields_filters.map { _1.filter_for(field.name) }
+                  end
+
+                  if field.fields_filter != ReeMapper::FieldsFilter::NoneStrategy
+                    nested_fields_filters += [field.fields_filter]
+                  end
+
+                  value = field.type.#{method}(
+                    value,
+                    name: nested_name,
+                    role: role,
+                    fields_filters: nested_fields_filters,
+                    location: field.location,
+                  )
                 end
 
                 @#{method}_strategy.assign_value(acc, field, value)

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

@@ -43,7 +43,13 @@ class ReeMapper::MapperFactory
           raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
         end
 
-        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
+        field = ReeMapper::Field.new(
+          type,
+          field_name,
+          optional: optional,
+          **opts,
+          location: caller_locations&.first&.to_s
+        )
 
         return field unless field_name
 
@@ -90,7 +96,8 @@ class ReeMapper::MapperFactory
 
         if blk
           subject = ReeMapper::Field.new(
-            hash_from_blk(dto: dto, &blk)
+            hash_from_blk(dto: dto, &blk),
+            location: caller_locations&.first&.to_s,
           )
         end
 
@@ -105,7 +112,13 @@ class ReeMapper::MapperFactory
         type = ReeMapper::Mapper.build(@mapper.strategies, wrapper.new(subject))
         type.name = :#{name}
 
-        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
+        field = ReeMapper::Field.new(
+          type,
+          field_name,
+          optional: optional,
+          **opts,
+          location: caller_locations&.first&.to_s,
+        )
 
         return field unless field_name
 
@@ -141,7 +154,7 @@ class ReeMapper::MapperFactory
 
     type = hash_from_blk(dto: dto, &blk)
 
-    field = ReeMapper::Field.new(type, field_name, **opts)
+    field = ReeMapper::Field.new(type, field_name, **opts, location: caller_locations&.first&.to_s)
 
     @mapper.add_field(field)
   end

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, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def serialize(value, name:, location: nil)
     value
   end
 
-  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def cast(value, name:, location: nil)
     value
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def db_dump(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def db_dump(value, name:, location: nil)
     value
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def db_load(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def db_load(value, name:, location: nil)
     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, 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