ree_lib 1.0.93 → 1.0.95

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/validation_error_spec.rb

@@ -1,8 +1,10 @@
 package_require('ree_errors/validation_error')
 
 RSpec.describe ReeErrors::ValidationError do
+  link :validation_error, from: :ree_errors
+
   it {
-    klass = described_class.build(:code)
+    klass = validation_error(:code)
     error = klass.new('message')
 
     expect(klass).to be_a(Class)

data/lib/ree_lib/packages/ree_i18n/Package.schema.json

@@ -25,6 +25,13 @@
         "fn"
       ]
     },
+    {
+      "name": "check_locale_exists",
+      "schema": "packages/ree_i18n/schemas/ree_i18n/functions/check_locale_exists.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
     {
       "name": "get_default_locale",
       "schema": "packages/ree_i18n/schemas/ree_i18n/functions/get_default_locale.schema.json",

data/lib/ree_lib/packages/ree_i18n/package/ree_i18n/functions/check_locale_exists.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ReeI18n::CheckLocaleExists
+  include Ree::FnDSL
+
+  fn :check_locale_exists
+
+  contract(String, Nilor[Or[String, Symbol]] => Bool)
+  def call(value, locale = nil)
+    I18n.exists?(value, locale || I18n.default_locale)
+  end
+end

data/lib/ree_lib/packages/ree_i18n/schemas/ree_i18n/functions/check_locale_exists.schema.json

@@ -0,0 +1,33 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "check_locale_exists",
+  "path": "packages/ree_i18n/package/ree_i18n/functions/check_locale_exists.rb",
+  "mount_as": "fn",
+  "class": "ReeI18n::CheckLocaleExists",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Bool",
+      "args": [
+        {
+          "arg": "value",
+          "arg_type": "req",
+          "type": "String"
+        },
+        {
+          "arg": "locale",
+          "arg_type": "opt",
+          "type": "Nilor[Or[String, Symbol]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_i18n/spec/ree_i18n/functions/check_locale_exists.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe :check_locale_exists do
+  link :set_locale, from: :ree_i18n
+  link :get_locale, from: :ree_i18n
+  link :add_load_path, from: :ree_i18n
+
+  it {
+    add_load_path(Dir[File.join(__dir__, 'locales/*.yml')])
+
+    expect(check_locale_exists("count.zero", "ru")).to eq(true)
+    expect(check_locale_exists("count.zero")).to eq(true)
+    expect(check_locale_exists("count.zero", :fr)).to eq(false)
+    expect(check_locale_exists("count.none", :ru)).to eq(false)
+  }
+end

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

@@ -1,25 +1,58 @@
 # frozen_string_literal: true
 
 class ReeMapper::ErrorWithLocation < ReeMapper::Error
-  attr_reader :location
+  attr_accessor :location
 
-  def initialize(message, location = nil)
-    if message.is_a?(String) && location && ENV["RUBY_ENV"] == "test"
-      message = "#{message}, located at #{location}"
-    end
-
-    super(message)
+  contract(String, String, ArrayOf[String]  => Any)
+  def initialize(message, location = nil, field_name_parts = [])
+    @message = message
     @location = location
+    @field_name_parts = field_name_parts
   end
 
-  def full_message(...)
-    msg = super
-    return msg if location.nil?
+  contract(String => nil)
+  def prepend_field_name(part)
+    @field_name_parts.unshift part
+    nil
+  end
+
+  contract(None => Nilor[String])
+  def field_name
+    @field_name_parts.reduce { "#{_1}[#{_2}]" }
+  end
+
+  if ENV["RUBY_ENV"] == "test"
+
+    contract(None => String)
+    def message
+      msg = @message
+
+      if location
+        msg = "#{msg}, located at #{location}"
+      end
+
+      return msg if @field_name_parts.empty?
 
-    idx = msg.index(/\).*\n/)
-    return msg if idx.nil?
-    return msg if ENV["RUBY_ENV"] == "test"
+      "`#{field_name}` #{msg}"
+    end
+
+  else
+
+    def message
+      return @message if @field_name_parts.empty?
+
+      "`#{field_name}` #{@message}"
+    end
+
+    def full_message(...)
+      msg = super
+      return msg if location.nil?
+
+      last_sym_idx = msg.index(/\).*\n/)
+      return msg if last_sym_idx.nil?
+
+      msg.insert(last_sym_idx + 1, ", located at #{location}")
+    end
 
-    msg.insert(idx + 1, ", located at #{location}")
   end
 end

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

@@ -33,7 +33,7 @@ class ReeMapper::Field
     @roles    = Array(role)
     @default  = default
 
-    @fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
+    @fields_filter = ReeMapper::FieldsFilter.build(only, except)
 
     @name_as_str               = @name.to_s
     @name_as_instance_var_name = :"@#{@name}"

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

@@ -55,35 +55,26 @@ class ReeMapper::FieldsFilter
     attr_reader :fields
   end
 
-  class NoneStrategy
-    def self.allow?(field)
-      true
-    end
-  end
-
-  def self.empty_filter
-    @empty_filter ||= new(NoneStrategy, {}).freeze
-  end
-
-  contract Nilor[ReeMapper::FilterFieldsContract], Nilor[ReeMapper::FilterFieldsContract] => Any
-  def self.build(only:, except:)
-    return empty_filter if only.nil? && except.nil?
-
+  contract(
+    Nilor[ReeMapper::FilterFieldsContract],
+    Nilor[ReeMapper::FilterFieldsContract] => Nilor[ReeMapper::FieldsFilter]
+  )
+  def self.build(only, except)
     strategy = if !only.nil?
       OnlyStrategy.new(only, except)
     elsif !except.nil?
       ExceptStrategy.new(except)
     else
-      NoneStrategy
+      return nil
     end
 
     nested_fields_filters = {}
-    
+
     only = only&.select { _1.is_a? Hash }&.reduce(&:merge)
     except = except&.select { _1.is_a? Hash }&.reduce(&:merge)
 
-    only&.each { nested_fields_filters[_1] = build(only: _2, except: except&.dig(_1)) }
-    except&.each { nested_fields_filters[_1] ||= build(only: nil, except: _2) }
+    only&.each { nested_fields_filters[_1] = build(_2, except&.dig(_1)) }
+    except&.each { nested_fields_filters[_1] ||= build(nil, _2) }
 
     new(strategy, nested_fields_filters)
   end
@@ -98,9 +89,9 @@ class ReeMapper::FieldsFilter
   end
 
   def filter_for(field)
-    nested_fields_filters.fetch(field, self.class.empty_filter)
+    nested_fields_filters[field]
   end
 
   private
   attr_reader :strategy, :nested_fields_filters
-end
+end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class ReeMapper::Mapper
-  EMPTY_ARY = [].freeze
-
   contract(
     ArrayOf[ReeMapper::MapperStrategy],
     Nilor[ReeMapper::AbstractType, ReeMapper::AbstractWrapper] => self
@@ -25,77 +23,67 @@ class ReeMapper::Mapper
 
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: EMPTY_ARY, location: nil)
+            def #{method}(obj, role: nil, only: nil, except: nil, fields_filters: nil)
               #{
                 if type.is_a?(ReeMapper::AbstractWrapper)
-                  "@type.#{method}(obj, name: name, role: role, fields_filters: fields_filters, location: location)"
+                  "@type.#{method}(obj, role:, fields_filters:)"
                 else
-                  "@type.#{method}(obj, name: name, location: location)"
+                  "@type.#{method}(obj)"
                 end
               }
             end
           RUBY
         else
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            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
-
-              if except && !ReeMapper::FilterFieldsContract.valid?(except)
-                raise ReeMapper::ArgumentError, "Invalid `except` format"
-              end
+            def #{method}(obj, role: nil, only: nil, except: nil, fields_filters: nil)
+              user_fields_filter = ReeMapper::FieldsFilter.build(only, except)
 
-              user_fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
-
-              @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
-                field_fields_filters = if user_fields_filter == ReeMapper::FieldsFilter::NoneStrategy
-                  fields_filters
+              if !user_fields_filter.nil?
+                fields_filters = if fields_filters.nil?
+                  [user_fields_filter]
                 else
                   fields_filters + [user_fields_filter]
                 end
+              end
 
-                next unless field_fields_filters.all? { _1.allow? field.name }
+              @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
+                next unless fields_filters.nil? || fields_filters.all? { _1.allow? field.name }
                 next unless field.has_role?(role)
 
-                is_with_value = @#{method}_strategy.has_value?(obj, field)
-                is_optional = field.optional || @#{method}_strategy.always_optional
-
-                if !is_with_value && !is_optional
-                  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?
-
-                value = if is_with_value
+                value = if @#{method}_strategy.has_value?(obj, field)
                   @#{method}_strategy.get_value(obj, field)
                 else
+                  if !field.optional && !@#{method}_strategy.always_optional
+                    raise ReeMapper::TypeError.new(
+                      "is missing required field",
+                      field.location,
+                      [field.from_as_str]
+                    )
+                  end
+
+                  next unless field.has_default?
+
                   field.default
                 end
 
-                unless value.nil? && field.null
-                  nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
+                if !value.nil? || !field.null
+                  nested_fields_filters = fields_filters&.filter_map { _1.filter_for(field.name) }
 
-                  nested_fields_filters = if field_fields_filters.empty?
-                    field_fields_filters
-                  else
-                    field_fields_filters.map { _1.filter_for(field.name) }
+                  if field.fields_filter
+                    nested_fields_filters = if nested_fields_filters
+                      nested_fields_filters + [field.fields_filter]
+                    else
+                      [field.fields_filter]
+                    end
                   end
 
-                  if field.fields_filter != ReeMapper::FieldsFilter::NoneStrategy
-                    nested_fields_filters += [field.fields_filter]
+                  value = begin
+                    field.type.#{method}(value, role:, fields_filters: nested_fields_filters)
+                  rescue ReeMapper::ErrorWithLocation => e
+                    e.prepend_field_name field.name_as_str
+                    e.location ||= field.location
+                    raise e
                   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/types/abstract_type.rb

@@ -2,7 +2,7 @@ class ReeMapper::AbstractType
   private
 
   def truncate(str, limit = 180)
-    @trancator ||= ReeString::Truncate.new
-    @trancator.call(str, limit)
+    @truncate ||= ReeString::Truncate.new
+    @truncate.(str, limit)
   end
 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, 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