ree_lib 1.0.20 → 1.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6972cd73aa8f6a7837528ca839deab2958095a3d23ad8fdb07a0db7963354669
-  data.tar.gz: 9439598c7328cca53fa6bfb7fe580725d55630793634d2674ad10e1a3dc96578
+  metadata.gz: 6a07548e9d6406a91f8b9ba8781ac7a42add43a8283225fec7147cebceaf3135
+  data.tar.gz: 277351000a4834065e02a5011966726d3121fac4451ec0dcfdb8d41a6ca2316c
 SHA512:
-  metadata.gz: 720520759e9483422ca206093e0f22e8cc7a490442a7cea13eae70b77be60e31895fc2180faf916a250ddd58a1a0a3e43d7ae1bdb417c88079b6f7cddcc51355
-  data.tar.gz: ebbea5de6b75a32c2f6c2ab7d6889258aa323121a578d575fbe77db3bf4004566b46ce747fb69a58067a5bda91246ca30df0cc00af1f19c3c74bde9fceb7fe0e
+  metadata.gz: 0d241902046d98abbe9affdecac2ed8d4c8ab588b078413a611b32b6b3054ae400296a96605a54ed7354a33106a5651d02bae1d6e7ef464570bac7c6cd11b897
+  data.tar.gz: d8f809aec0100f1727c0d8e411a6a1f192c4120b7e60dcdb4c00fea1f1503137cb368a1064aa3e74e0d25d94354090b4f2200ec1e0337074493bf08bf837a57c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.20)
+    ree_lib (1.0.22)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -35,32 +35,34 @@ GEM
     loofah (2.18.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
-    msgpack (1.5.4)
-    nokogiri (1.13.8-x86_64-linux)
+    msgpack (1.6.0)
+    nokogiri (1.13.9-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.13.9-x86_64-linux)
       racc (~> 1.4)
     oj (3.13.21)
-    pg (1.4.3)
+    pg (1.4.4)
     public_suffix (5.0.0)
     racc (1.6.0)
     rainbow (3.1.1)
     rake (13.0.6)
-    ree (1.0.5)
+    ree (1.0.6)
       commander (~> 4.6.0)
     rexml (3.2.5)
-    rollbar (3.3.1)
+    rollbar (3.3.2)
     rspec (3.11.0)
       rspec-core (~> 3.11.0)
       rspec-expectations (~> 3.11.0)
       rspec-mocks (~> 3.11.0)
     rspec-core (3.11.0)
       rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rspec-expectations (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
+    rspec-mocks (3.11.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
+    rspec-support (3.11.1)
     sequel (5.58.0)
     sqlite3 (1.4.4)
     timecop (0.9.5)

data/lib/ree_lib/packages/ree_dao/package/ree_dao/dataset_extensions.rb

@@ -111,16 +111,20 @@ module ReeDao
       end
 
       def update(entity)
-        raw = opts[:schema_mapper].db_dump(entity)
-        raw = extract_changes(entity, raw)
+        if opts[:schema_mapper]
+          raw = opts[:schema_mapper].db_dump(entity)
+          raw = extract_changes(entity, raw)
+
+          unless raw.empty?
+            update_persistence_state(entity, raw)
+            key_condition = prepare_key_condition_from_entity(entity)
+            where(key_condition).__original_update(raw)
+          end
 
-        unless raw.empty?
-          update_persistence_state(entity, raw)
-          key_condition = prepare_key_condition_from_entity(entity)
-          where(key_condition).__original_update(raw)
+          entity
+        else
+          __original_update(entity)
         end
-
-        entity
       end
 
       def delete(entity = nil)

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/find_human_time_zones_by_offset_spec.rb

@@ -6,7 +6,6 @@ RSpec.describe :find_human_time_zones_by_offset do
   it {
     gmt_12 = find_human_time_zones_by_offset("+12:00")
 
-    expect(gmt_12.length).to eq(4)
     expect(gmt_12).to be_a(Array)
   }
 end

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/find_time_zones_by_offset_spec.rb

@@ -6,7 +6,6 @@ RSpec.describe :find_time_zones_by_offset do
   it {
     gmt_12 = find_time_zones_by_offset("+12:00")
 
-    expect(gmt_12.length).to eq(16)
     expect(gmt_12).to be_a(Array)
   }
 end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ReeMapper::ArgumentError < ReeMapper::Error
+end

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

@@ -2,7 +2,8 @@
 
 class ReeMapper::Field
   attr_reader :type, :name, :from, :doc, :optional, :null, :roles, :default,
-              :name_as_str, :name_as_instance_var_name, :from_as_str
+              :name_as_str, :name_as_instance_var_name, :from_as_str,
+              :fields_filter
 
   NO_DEFAULT = Object.new.freeze
 
@@ -15,10 +16,13 @@ class ReeMapper::Field
       optional: Bool,
       null:     Bool,
       role:     Nilor[ArrayOf[Symbol], Symbol],
-      default:  Any
+      default:  Any,
+      only:     Nilor[ReeMapper::FilterFieldsContract],
+      except:   Nilor[ReeMapper::FilterFieldsContract]
     ] => Any
   ).throws(ArgumentError)
-  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT)
+  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT, 
+                 only: nil, except: nil)
     @type     = type
     @name     = name
     @from     = from || name
@@ -28,6 +32,8 @@ class ReeMapper::Field
     @roles    = Array(role)
     @default  = default
 
+    @fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
+
     @name_as_str               = @name.to_s
     @name_as_instance_var_name = :"@#{@name}"
     @from_as_str               = @from.to_s

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class ReeMapper::FieldsFilter
+  class OnlyStrategy
+    def initialize(only, except)
+      @fields = Set.new
+
+      only.each do |item|
+        if item.is_a? Symbol
+          @fields << item
+        else
+          item.each do |key, val|
+            @fields << key
+          end
+        end
+      end
+
+      if !except.nil?
+        except.each do |item|
+          if item.is_a? Symbol
+            @fields.delete item
+          else
+            item.each do |key, val|
+              @fields.delete key
+            end
+          end
+        end
+      end
+    end
+
+    def allow?(field)
+      fields.include? field
+    end
+
+    private
+    attr_reader :fields
+  end
+
+  class ExceptStrategy
+    def initialize(except)
+      @fields = Set.new
+
+      except&.each do |item|
+        if item.is_a? Symbol
+          @fields << item
+        end
+      end
+    end
+
+    def allow?(field)
+      !fields.include?(field)
+    end
+
+    private
+    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?
+
+    strategy = if !only.nil?
+      OnlyStrategy.new(only, except)
+    elsif !except.nil?
+      ExceptStrategy.new(except)
+    else
+      NoneStrategy
+    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) }
+
+    new(strategy, nested_fields_filters)
+  end
+
+  def initialize(strategy, nested_fields_filters)
+    @strategy              = strategy
+    @nested_fields_filters = nested_fields_filters
+  end
+
+  def allow?(field)
+    strategy.allow?(field)
+  end
+
+  def filter_for(field)
+    nested_fields_filters.fetch(field, self.class.empty_filter)
+  end
+
+  private
+  attr_reader :strategy, :nested_fields_filters
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ReeMapper::FilterFieldsContract
+  def self.valid?(value)
+    return false unless value.is_a? Array
+
+    value.each do |item|
+      next if item.is_a? Symbol
+      return false unless item.is_a? Hash
+
+      item.each do |key, val|
+        return false unless key.is_a?(Symbol)
+        return false unless valid?(val)
+      end
+    end
+
+    true
+  end
+
+  def self.to_s
+    "FilterFieldsContract"
+  end
+
+  def self.message(*)
+    "Invalid filter fields contract"
+  end
+end

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

@@ -19,34 +19,58 @@ class ReeMapper::Mapper
 
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil)
-              @type.#{method}(obj, name: name, role: role)
+            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: [])
+              if @type.is_a?(ReeMapper::Array)
+                @type.#{method}(obj, name: name, role: role, fields_filters: fields_filters)
+              else
+                @type.#{method}(obj, name: name, role: role)
+              end
             end
           RUBY
         else
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil)
+            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: [])
+              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
+
+              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]
+
+                next unless field_fields_filters.all? { _1.allow? field.name }
                 next unless field.has_role?(role)
-                nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
-
-                if @#{method}_strategy.has_value?(obj, field)
-                  value = @#{method}_strategy.get_value(obj, field)
-                  unless value.nil? && field.null
-                    value = field.type.#{method}(value, name: nested_name, role: role)
-                  end
-                  @#{method}_strategy.assign_value(acc, field, value)
-                elsif field.optional || @#{method}_strategy.always_optional
-                  if field.has_default?
-                    value = field.default
-                    unless value.nil? && field.null
-                      value = field.type.#{method}(value, name: nested_name, role: role)
-                    end
-                    @#{method}_strategy.assign_value(acc, field, value)
-                  end
-                else
+
+                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, "Missing required field `\#{field.from_as_str}` for `\#{name || 'root'}`"
                 end
+
+                next if !is_with_value && !field.has_default?
+
+                value = if is_with_value
+                  @#{method}_strategy.get_value(obj, field)
+                else
+                  field.default
+                end
+
+                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)
+                end
+
+                @#{method}_strategy.assign_value(acc, field, value)
               end
             end
           RUBY

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

@@ -76,6 +76,7 @@ class ReeMapper::MapperFactory
     raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
     raise ArgumentError, 'array type should use either :each or :block' if each && blk || !each && !blk
     raise ArgumentError, 'invalid :key option value' unless HASH_KEY_OPTION_VALUES.include?(key)
+    raise ArgumentError, 'array does not permit :only and :except keys' if opts.key?(:only) || opts.key?(:except)
 
     if blk
       each = ReeMapper::Field.new(

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

@@ -8,14 +8,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     @of = of
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  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: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else
@@ -23,14 +24,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  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: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.cast(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else
@@ -38,14 +40,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
+  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: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else
@@ -53,14 +56,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
+  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: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else

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

@@ -16,7 +16,10 @@ module ReeMapper
   require_relative 'ree_mapper/errors/coercion_error'
   require_relative 'ree_mapper/errors/type_error'
   require_relative 'ree_mapper/errors/unsupported_type_error'
+  require_relative 'ree_mapper/errors/argument_error'
 
+  require_relative 'ree_mapper/filter_fields_contract'
+  require_relative 'ree_mapper/fields_filter'
   require_relative 'ree_mapper/field'
 
   require_relative 'ree_mapper/types/bool'

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

@@ -15,6 +15,142 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     )
   }
 
+  describe 'only and except' do
+    before {
+      mapper_factory.call(register_as: :point).use(:cast) {
+        integer :x
+        integer :y
+        integer :z
+      } 
+    }
+
+    context 'with only' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          integer :id
+          integer? :opt_id
+          point :point, only: [:x, :y]
+        }
+      }
+
+      it {
+        expect(mapper.cast({ id: 1, point: { x: 1, y: 1 } })).to eq({ id: 1, point: { x: 1, y: 1 } })
+      }
+
+      it {
+        expect(mapper.cast({ opt_id: 1, point: { x: 1 } }, only: [:opt_id, point: [:x]])).to eq({ opt_id: 1, point: { x: 1 } })
+      }
+    end
+
+    context 'with except' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          integer :id
+          point :point, except: [:z]
+        }
+      }
+
+      it {
+        expect(mapper.cast({ id: 1, point: { x: 1, y: 1 } })).to eq({ id: 1, point: { x: 1, y: 1 } })
+      }
+
+      it {
+        expect(mapper.cast({ id: 1, point: { x: 1 } }, except: [:id, point: [:y]])).to eq({ point: { x: 1 } })
+      }
+    end
+
+    context 'with only and except' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          integer :included
+          integer :excluded
+          point :point, only: [:x, :y], except: [:y]
+
+          hash :matrix do
+            point :x, only: [:x]
+            point :y, except: [:x, :z]
+          end
+
+          array :points, each: point(only: [:x, :y])
+        }
+      }
+
+      it {
+        expect(mapper.cast(
+          {
+            included: 1,
+            excluded: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 }, y: { y: 1 } },
+            points: [{ x: 1, y: 1}]
+          }
+        )).to eq(
+          {
+            included: 1,
+            excluded: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 }, y: { y: 1 } },
+            points: [{ x: 1, y: 1 }]
+          }
+        )
+      }
+
+      it {
+        expect(mapper.cast(
+          {
+            included: 1,
+            excluded: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 }, y: { y: 1 } },
+            points: [{ x: 1, y: 1}]
+          },
+          only: [:included, point: [:x], matrix: [x: [:x]], points: [:x]]
+        )).to eq(
+          {
+            included: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 } },
+            points: [{ x: 1 }]
+          }
+        )
+      }
+    end
+
+    context 'with invalid only' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          point :point
+        }
+      }
+
+      it {
+        expect {
+          mapper.cast({}, only: {})
+        }.to raise_error(
+          ReeMapper::ArgumentError,
+          "Invalid `only` format"
+        )
+      }
+    end
+
+    context 'with invalid except' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          point :point
+        }
+      }
+
+      it {
+        expect {
+          mapper.cast({}, except: {})
+        }.to raise_error(
+          ReeMapper::ArgumentError,
+          "Invalid `except` format"
+        )
+      }
+    end
+  end
+
   describe 'from:' do
     let(:mapper) {
       mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {

data/lib/ree_lib/packages/ree_swagger/package/ree_swagger/functions/build_parameters.rb

@@ -36,7 +36,7 @@ class ReeSwagger::BuildParameters
         name: field.name_as_str,
         in: is_path_param ? 'path' : 'query',
         required: is_path_param || !field.optional,
-        schema: build_request_body_schema(field.type) || {}
+        schema: build_request_body_schema(field.type, [], [field.fields_filter]) || {}
       }
 
       schema[:style] = 'deepObject' if field.type.type.nil?

data/lib/ree_lib/packages/ree_swagger/package/ree_swagger/functions/build_request_body_schema.rb

@@ -9,9 +9,10 @@ class ReeSwagger::BuildRequestBodySchema
 
   contract(
     ReeMapper::Mapper,
-    ArrayOf[Symbol] => Nilor[Hash]
+    ArrayOf[Symbol],
+    ArrayOf[ReeMapper::FieldsFilter] => Nilor[Hash]
   )
-  def call(mapper, path_params = [])
+  def call(mapper, path_params = [], fields_filters = [])
     if mapper.type
       return get_caster_definition(mapper.type, method(:call).to_proc)
     end
@@ -19,13 +20,20 @@ class ReeSwagger::BuildRequestBodySchema
     required_fields = []
 
     properties = mapper.fields.each_with_object({}) do |(_name, field), acc|
+      next unless fields_filters.all? { _1.allow?(field.name) }
+
       next if path_params.include?(field.name)
 
       swagger_field = {}
 
       required_fields << field.name.to_s if !field.optional
       field_mapper = field.type
-      swagger_type = call(field_mapper)
+
+      nested_fields_filters = fields_filters.map { _1.filter_for(field.name) }
+      nested_fields_filters += [field.fields_filter]
+
+      swagger_type = call(field_mapper, [], nested_fields_filters)
+
       swagger_field.merge!(swagger_type) if swagger_type
 
       description = field.doc

data/lib/ree_lib/packages/ree_swagger/package/ree_swagger/functions/build_serializer_schema.rb

@@ -7,17 +7,24 @@ class ReeSwagger::BuildSerializerSchema
     link :get_serializer_definition
   end
 
-  contract(ReeMapper::Mapper => Nilor[Hash])
-  def call(mapper)
+  contract(ReeMapper::Mapper, ArrayOf[ReeMapper::FieldsFilter] => Nilor[Hash])
+  def call(mapper, fields_filters = [])
     if mapper.type
       return get_serializer_definition(mapper.type, method(:call).to_proc)
     end
 
     properties = mapper.fields.each_with_object({}) do |(_name, field), acc|
+      next unless fields_filters.all? { _1.allow?(field.name) }
+
       swagger_field = {}
 
       field_mapper = field.type
-      swagger_type = call(field_mapper)
+
+      nested_fields_filters = fields_filters.map { _1.filter_for(field.name) }
+      nested_fields_filters += [field.fields_filter]
+
+      swagger_type = call(field_mapper, nested_fields_filters)
+
       swagger_field.merge!(swagger_type) if swagger_type
 
       description = field.doc

data/lib/ree_lib/packages/ree_swagger/schemas/ree_swagger/functions/build_request_body_schema.schema.json

@@ -21,6 +21,10 @@
         {
           "arg": "path_params",
           "type": "ArrayOf[Symbol]"
+        },
+        {
+          "arg": "fields_filters",
+          "type": "ArrayOf[ReeMapper::FieldsFilter]"
         }
       ]
     }

data/lib/ree_lib/packages/ree_swagger/schemas/ree_swagger/functions/build_serializer_schema.schema.json

@@ -17,6 +17,10 @@
         {
           "arg": "mapper",
           "type": "ReeMapper::Mapper"
+        },
+        {
+          "arg": "fields_filters",
+          "type": "ArrayOf[ReeMapper::FieldsFilter]"
         }
       ]
     }

data/lib/ree_lib/packages/ree_swagger/spec/functions/build_endpoint_schema_spec.rb

@@ -51,23 +51,16 @@ RSpec.describe :build_endpoint_schema do
     _tag_caster = mapper_factory.call(register_as: :tag).use(:cast) do
       string :name
       string :value
+      string :excluded
     end
 
     caster = mapper_factory.call.use(:cast) do
       integer :id
       string :name
-      tag    :tag
+      tag    :tag, except: [:excluded]
       locales :locale
     end
 
-    file_caster = mapper_factory.call.use(:cast) do
-      integer :id
-    end
-
-    file_serializer = mapper_factory.call.use(:serialize) do
-      string :data
-    end
-
     schema = build_endpoint_schema(ReeSwagger::EndpointDto.new(
       method:          :post,
       respond_to:      :json,
@@ -95,20 +88,6 @@ RSpec.describe :build_endpoint_schema do
       ]
     ))
 
-    csv_schema = build_endpoint_schema(ReeSwagger::EndpointDto.new(
-      method:          :get,
-      respond_to:      :csv,
-      authenticate:    false,
-      path:            '/files/:id',
-      sections:        ["files"],
-      caster:          file_caster,
-      serializer:      file_serializer,
-      response_status: 200,
-      description:     "file",
-      summary:         "file summary",
-      errors:          []
-    ))
-
     expect(schema).to eq(ReeSwagger::PathDto.new(
       path: '/versions/{id}',
       schema: {
@@ -174,6 +153,116 @@ RSpec.describe :build_endpoint_schema do
         }
       }
     ))
+  }
+
+  it {
+    serializer = mapper_factory.call.use(:serialize) do
+      integer :id
+    end
+
+    _tag_caster = mapper_factory.call(register_as: :tag).use(:cast) do
+      string :name
+      string :value
+      string :excluded
+    end
+
+    caster = mapper_factory.call.use(:cast) do
+      integer :id
+      string :name
+      tag    :tag, except: [:excluded]
+    end
+
+    schema = build_endpoint_schema(ReeSwagger::EndpointDto.new(
+      method:          :get,
+      respond_to:      :json,
+      authenticate:    false,
+      path:            '/versions/:id',
+      sections:        ["versions"],
+      caster:          caster,
+      serializer:      serializer,
+      response_status: 200,
+      description:     "description",
+      summary:         "summary",
+      errors:          []
+    ))
+
+    expect(schema).to eq(ReeSwagger::PathDto.new(
+      path: '/versions/{id}',
+      schema: {
+        get: {
+          parameters: [
+            {
+              name: 'id',
+              in: 'path',
+              required: true,
+              schema: { type: 'integer' }
+            },
+            {
+              name: 'name',
+              in: 'query',
+              required: true,
+              schema: { type: 'string' }
+            },
+            {
+              name: 'tag',
+              in: 'query',
+              required: true,
+              style: 'deepObject',
+              schema: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  value: { type: 'string' }
+                },
+                required: ['name', 'value']
+              }
+            }
+          ],
+          responses: {
+            200 => {
+              description: '',
+              content: {
+                :'application/json' => {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      id: { type: 'integer' }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          summary: "summary",
+          description: "description",
+          tags: ["versions"]
+        }
+      }
+    ))
+  }
+
+  it {
+    file_caster = mapper_factory.call.use(:cast) do
+      integer :id
+    end
+
+    file_serializer = mapper_factory.call.use(:serialize) do
+      string :data
+    end
+
+    csv_schema = build_endpoint_schema(ReeSwagger::EndpointDto.new(
+      method:          :get,
+      respond_to:      :csv,
+      authenticate:    false,
+      path:            '/files/:id',
+      sections:        ["files"],
+      caster:          file_caster,
+      serializer:      file_serializer,
+      response_status: 200,
+      description:     "file",
+      summary:         "file summary",
+      errors:          []
+    ))
 
     expect(csv_schema).to eq(ReeSwagger::PathDto.new(
       path: '/files/{id}',

data/lib/ree_lib/packages/ree_swagger/spec/functions/build_serializer_schema_spec.rb

@@ -25,6 +25,17 @@ RSpec.describe :build_serializer_schema do
   }
 
   let(:mapper) {
+    nested_partial_mapper = mapper_factory.call(register_as: :nested_partial).use(:serialize) do
+      string :included
+      string :excepted
+      string :nested_excepted
+    end
+
+    partial_mapper = mapper_factory.call(register_as: :partial).use(:serialize) do
+      string :excepted
+      nested_partial :nested_partial_value, except: [:excepted]
+    end
+
     setting_mapper = mapper_factory.call(register_as: :setting).use(:serialize) do
       string :name
       string :value
@@ -55,6 +66,8 @@ RSpec.describe :build_serializer_schema do
       integer :test_null, null: true
 
       unregistered_type :test_unregistered_type
+
+      partial :partial_value, except: [:excepted, nested_partial_value: [:nested_excepted]]
     end
   }
 
@@ -102,7 +115,18 @@ RSpec.describe :build_serializer_schema do
             type: 'integer',
             nullable: true
           },
-          test_unregistered_type: {}
+          test_unregistered_type: {},
+          partial_value: {
+            type: 'object',
+            properties: { 
+              nested_partial_value: {
+                type: 'object',
+                properties: { 
+                  included: { type: 'string' }
+                }
+              }
+            }
+          },
         }
       }
     )

data/lib/ree_lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.20
+  version: 1.0.22
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-28 00:00:00.000000000 Z
+date: 2022-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -906,11 +906,14 @@ files:
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/default_factory.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/dsl.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/argument_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/coercion_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/type_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/unsupported_type_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/field.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/fields_filter.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/filter_fields_contract.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_factory.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_strategy.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper.rb