store_model 1.6.1 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4731608dcbfcf457b9e0cce52d04766ccbc7ea38fc061a6af61ef3b6edc2a3c
-  data.tar.gz: d5a84b08a03420aece94ea78a0c620d3e486ac4046173d6b6091974f94f4c507
+  metadata.gz: fe31f43187a97021f54c79cbc8372b7e2b1c5a3c4bcb7b07b13def128bf69f34
+  data.tar.gz: '0456813d7c47e3a9888c23bd83dc90c233f8919734766e348c064350c3d502ce'
 SHA512:
-  metadata.gz: 9e78d0f1f95f9982ed599f5701e06d48936f2be349189764b5fa7df6fc7a0c9ee71a17d1ae50a74c1a70bcbb037feb8e33db43131de1e880efb74c9a2c0e9c9d
-  data.tar.gz: 7d5d82c70fe870f3abc767faae918a2a8f11bc6a9d645a8d36d12800da19951b9a8f018cdc336e5c35979a5e21847a034d1d9b76196a87c6bd1a1d0389062a80
+  metadata.gz: 54a697b1a4782fa6bf3a6f84972789f6b42aab7ef9702e243d7fa4b9d7a6c035ea1421a560eb848083dd414b9bd594d577ca82a50642718d80607d742db64561
+  data.tar.gz: d591bf765bb19d91cc7972762349075edbb5ec9d633f3b0e4b9c290069af132e35b9d011e4537de43c18f3de76ca863e8b0576d93502ac95b24e4abb250bedd3

data/README.md

@@ -1,4 +1,4 @@
-# StoreModel [![Gem Version](https://badge.fury.io/rb/store_model.svg)](https://rubygems.org/gems/store_model) [![Coverage Status](https://coveralls.io/repos/github/DmitryTsepelev/store_model/badge.svg?branch=master)](https://coveralls.io/github/DmitryTsepelev/store_model?branch=master) ![](https://ruby-gem-downloads-badge.herokuapp.com/store_model?type=total)
+# StoreModel [![Gem Version](https://badge.fury.io/rb/store_model.svg)](https://rubygems.org/gems/store_model) ![](https://ruby-gem-downloads-badge.herokuapp.com/store_model?type=total)
 
 **StoreModel** gem allows you to wrap JSON-backed DB columns with ActiveModel-like classes.
 
@@ -22,6 +22,8 @@ class Product < ApplicationRecord
 end
 ```
 
+You can support my open–source work [here](https://boosty.to/dmitry_tsepelev).
+
 ## Why should I wrap my JSON columns?
 
 Imagine that you have a model `Product` with a `jsonb` column called `configuration`. This is how you likely gonna work with this column:
@@ -76,20 +78,66 @@ product.save
 _Usage note: Rails and assigning Arrays/Hashes to records_
 
 - Assigned attributes must be a String, Hash, Array of Hashes, or StoreModel. For example, if the attributes are coming from a controller, be sure to convert any ActionController::Parameters as needed.
-- Any changes made to a StoreModel instance requires the attribute be re-assigned; Rails doesn't track mutations of objects. For example: `self.my_stored_models = my_stored_models.map(&:as_json)`
+- Any changes made to a StoreModel instance requires the attribute be flagged as dirty, either by reassignment (`self.my_stored_models = my_stored_models.map(&:as_json)`) or by `will_change!` (`self.my_stored_models_will_change!`)
+- Mixing `StoreModel::NestedAttributes` into your model will allow you to use `accepts_nested_attributes_for` in the same way as ActiveRecord.
+
+```ruby
+class Supplier < ActiveRecord::Base
+  include StoreModel::NestedAttributes
+
+  has_many :bicycles, dependent: :destroy
+
+  attribute :products, Product.to_array_type
+
+  accepts_nested_attributes_for :bicycles, :products, allow_destroy: true
+end
+```
+
+This will allow the form builders to work their magic:
+
+```erb
+<%= form_with model: @supplier do |form| %>
+  <%= form.fields_for :products do |product_fields| %>
+    <%= product_fields.text_field :name %>
+  <% end %>
+<% end %>
+```
+
+Resulting in:
+```html
+<input type="text" name="supplier[products_attributes][0][name]" id="supplier_products_attributes_0_name">
+```
+
+In the controller:
+```ruby
+def create
+  @supplier = Supplier.from_value(supplier_params)
+  @supplier.save
+end
+
+private
+
+def supplier_params
+  params.require(:supplier).permit(products_attributes: [:name])
+end
+```
 
 ## Documentation
 
 1. [Installation](./docs/installation.md)
-2. StoreModel::Model API:
+2. `StoreModel::Model` API:
+  * [Instantiation](./docs/instantiation.md)
   * [Validations](./docs/validations.md)
   * [Enums](./docs/enums.md)
   * [Nested models](./docs/nested_models.md)
   * [Unknown attributes](./docs/unknown_attributes.md)
+  * [Empty attributes](./docs/empty_attributes.md)
 3. [Array of stored models](./docs/array_of_stored_models.md)
-4. [One of](./docs/one_of.md)
-4. [Alternatives](./docs/alternatives.md)
-5. [Defining custom types](./docs/defining_custom_types.md)
+4. [Hash of stored models](./docs/hash_of_stored_models.md)
+5. [One of](./docs/one_of.md)
+6. [Alternatives](./docs/alternatives.md)
+7. [Defining custom types](./docs/defining_custom_types.md)
+8. [Disabling Parent Tracking](./docs/enable_parent_assignment.md)
 
 ## Credits
 

data/lib/active_model/validations/store_model_validator.rb

@@ -14,6 +14,7 @@ module ActiveModel
       # @param record [ApplicationRecord] object to validate
       # @param attribute [String] name of the validated attribute
       # @param value [Object] value of the validated attribute
+      # rubocop:disable Metrics/MethodLength
       def validate_each(record, attribute, value)
         if value.nil?
           record.errors.add(attribute, :blank)
@@ -25,8 +26,11 @@ module ActiveModel
           call_json_strategy(record, attribute, value)
         when :array, :polymorphic_array
           call_array_strategy(record, attribute, value)
+        when :hash, :polymorphic_hash
+          call_hash_strategy(record, attribute, value)
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -39,6 +43,11 @@ module ActiveModel
         array_strategy.call(attribute, record.errors, value) if any_invalid
       end
 
+      def call_hash_strategy(record, attribute, value)
+        invalid_values = value.select { |_k, v| v.invalid?(record.validation_context) }
+        hash_strategy.call(attribute, record.errors, invalid_values) if invalid_values.present?
+      end
+
       def strategy
         @strategy ||= StoreModel::CombineErrorsStrategies.configure(options)
       end
@@ -46,6 +55,10 @@ module ActiveModel
       def array_strategy
         @array_strategy ||= StoreModel::CombineErrorsStrategies.configure_array(options)
       end
+
+      def hash_strategy
+        @hash_strategy ||= StoreModel::CombineErrorsStrategies.configure_hash(options)
+      end
     end
   end
 end

data/lib/store_model/combine_errors_strategies/mark_invalid_error_strategy.rb

@@ -10,8 +10,8 @@ module StoreModel
       # @param base_errors [ActiveModel::Errors] errors object of the parent record
       # @param _store_model_errors [ActiveModel::Errors] errors object of the
       # StoreModel::Model attribute
-      def call(attribute, base_errors, _store_model_errors)
-        base_errors.add(attribute, :invalid)
+      def call(attribute, base_errors, store_model_errors)
+        base_errors.add(attribute, :invalid, errors: store_model_errors)
       end
     end
   end

data/lib/store_model/combine_errors_strategies/merge_hash_error_strategy.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StoreModel
+  module CombineErrorsStrategies
+    # +MergeHashErrorStrategy+ copies errors from the StoreModel::Model to the parent
+    # record attribute errors with hash key prefixes.
+    class MergeHashErrorStrategy
+      # Merges errors on +attribute+ from the child model with parent errors.
+      #
+      # @param attribute [String] name of the validated attribute
+      # @param base_errors [ActiveModel::Errors] errors object of the parent record
+      # @param store_models [Hash] a hash of store_models that have been validated
+      def call(attribute, base_errors, store_models)
+        store_models.each do |key, store_model|
+          store_model.errors.full_messages.each do |full_message|
+            base_errors.add(attribute, :invalid, message: "[#{key}] #{full_message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/store_model/combine_errors_strategies.rb

@@ -3,6 +3,7 @@
 require "store_model/combine_errors_strategies/mark_invalid_error_strategy"
 require "store_model/combine_errors_strategies/merge_error_strategy"
 require "store_model/combine_errors_strategies/merge_array_error_strategy"
+require "store_model/combine_errors_strategies/merge_hash_error_strategy"
 
 module StoreModel
   # Module with built-in strategies for combining errors.
@@ -37,6 +38,20 @@ module StoreModel
       )
     end
 
+    # Finds a hash strategy based on +options+ and global config.
+    #
+    # @param options [Hash]
+    #
+    # @return [Object] strategy
+    def configure_hash(options)
+      configured_strategy = options[:merge_hash_errors] || StoreModel.config.merge_hash_errors
+
+      get_configured_strategy(
+        configured_strategy,
+        StoreModel::CombineErrorsStrategies::MergeHashErrorStrategy
+      )
+    end
+
     def get_configured_strategy(configured_strategy, true_strategy_class)
       if configured_strategy.respond_to?(:call)
         configured_strategy

data/lib/store_model/configuration.rb

@@ -11,12 +11,32 @@ module StoreModel
     # @return [Boolean]
     attr_accessor :merge_array_errors
 
+    # Controls usage of MergeHashErrorStrategy
+    # @return [Boolean]
+    attr_accessor :merge_hash_errors
+
     # Controls if the result of `as_json` will contain the unknown attributes of the model
     # @return [Boolean]
     attr_accessor :serialize_unknown_attributes
 
+    # Controls if the result of `as_json` will contain the nulls attributes of the model
+    # @return [Boolean]
+    attr_accessor :serialize_empty_attributes
+
+    # Controls if the result of `as_json` will serialize enum fields using `as_json`
+    # @return [Boolean]
+    attr_accessor :serialize_enums_using_as_json
+
+    # Controls if parent tracking functionality is enabled.
+    # Default: true
+    # @return [Boolean]
+    attr_accessor :enable_parent_assignment
+
     def initialize
       @serialize_unknown_attributes = true
+      @enable_parent_assignment = true
+      @serialize_enums_using_as_json = true
+      @serialize_empty_attributes = true
     end
   end
 end

data/lib/store_model/enum.rb

@@ -10,12 +10,12 @@ module StoreModel
     # @param kwargs [Object]
     def enum(name, values = nil, **kwargs)
       values ||= kwargs[:in] || kwargs
-      options = kwargs.slice(:_prefix, :_suffix, :default)
+      options = retrieve_options(kwargs)
 
       ensure_hash(values).tap do |mapping|
-        define_attribute(name, mapping, options[:default])
+        define_attribute(name, mapping, options)
         define_reader(name, mapping)
-        define_writer(name, mapping)
+        define_writer(name, mapping, options[:raise_on_invalid_values])
         define_method("#{name}_value") { attributes[name.to_s] }
         define_map_readers(name, mapping)
         define_predicate_methods(name, mapping, options)
@@ -24,16 +24,25 @@ module StoreModel
 
     private
 
-    def define_attribute(name, mapping, default)
-      attribute name, cast_type(mapping), default: default
+    def retrieve_options(options)
+      default_options = { raise_on_invalid_values: true }
+      options.slice(:_prefix, :_suffix, :default, :raise_on_invalid_values)
+             .reverse_merge(default_options)
+    end
+
+    def define_attribute(name, mapping, options)
+      attribute name, cast_type(mapping, options[:raise_on_invalid_values]), default: options[:default]
     end
 
     def define_reader(name, mapping)
-      define_method(name) { mapping.key(send("#{name}_value")).to_s }
+      define_method(name) do
+        raw_value = send("#{name}_value")
+        (mapping.key(raw_value) || raw_value).to_s
+      end
     end
 
-    def define_writer(name, mapping)
-      type = cast_type(mapping)
+    def define_writer(name, mapping, raise_on_invalid_values)
+      type = cast_type(mapping, raise_on_invalid_values)
       define_method("#{name}=") { |value| super type.cast_value(value) }
     end
 
@@ -50,8 +59,8 @@ module StoreModel
       singleton_class.alias_method(ActiveSupport::Inflector.pluralize(name), "#{name}_values")
     end
 
-    def cast_type(mapping)
-      StoreModel::Types::EnumType.new(mapping)
+    def cast_type(mapping, raise_on_invalid_values)
+      StoreModel::Types::EnumType.new(mapping, raise_on_invalid_values)
     end
 
     def ensure_hash(values)

data/lib/store_model/ext/parent_assignment.rb

@@ -7,9 +7,9 @@ module StoreModel
 
     def assign_parent_to_store_model_relation(attribute)
       assign_parent_to_singular_store_model(attribute)
-      return unless attribute.is_a?(Array)
+      return if !attribute.is_a?(Array) && !attribute.is_a?(Hash)
 
-      attribute.each(&method(:assign_parent_to_singular_store_model))
+      (attribute.try(:values) || attribute).each(&method(:assign_parent_to_singular_store_model))
     end
 
     def assign_parent_to_singular_store_model(item)

data/lib/store_model/model.rb

@@ -7,7 +7,8 @@ require "store_model/nested_attributes"
 
 module StoreModel
   # When included into class configures it to handle JSON column
-  module Model
+  module Model # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable Metrics/MethodLength
     def self.included(base) # :nodoc:
       base.include ActiveModel::Model
       base.include ActiveModel::Attributes
@@ -15,13 +16,40 @@ module StoreModel
       base.include ActiveModel::AttributeMethods
       base.include StoreModel::NestedAttributes
 
+      if ActiveModel::VERSION::MAJOR >= 8 && ActiveModel::VERSION::MINOR >= 1
+        base.include ActiveModel::Attributes::Normalization
+      end
+
       base.extend StoreModel::Enum
       base.extend StoreModel::TypeBuilders
 
       base.attribute_method_suffix "?"
+
+      base.extend(ClassMethods)
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Class methods for StoreModel::Model
+    module ClassMethods
+      def from_value(value)
+        to_type.cast_value(value)
+      end
+
+      def from_values(values)
+        to_array_type.cast_value(values)
+      end
+
+      # Defines a discriminator attribute with a value
+      # @param discriminator [Symbol, String] attribute name (default: :type)
+      # @param type [Symbol, String] attribute type (default: :string)
+      # @param value [String] the discriminator value
+      def discriminator_attribute(discriminator = "type", value:, type: :string)
+        attribute discriminator, type, default: value
+      end
     end
 
     attr_accessor :parent
+    attr_writer :serialize_unknown_attributes, :serialize_enums_using_as_json, :serialize_empty_attributes
 
     delegate :each_value, to: :attributes
 
@@ -31,16 +59,39 @@ module StoreModel
     # @param options [Hash]
     #
     # @return [Hash]
-    def as_json(options = {})
+    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       serialize_unknown_attributes = if options.key?(:serialize_unknown_attributes)
                                        options[:serialize_unknown_attributes]
                                      else
                                        StoreModel.config.serialize_unknown_attributes
                                      end
 
-      result = attributes.with_indifferent_access
+      serialize_enums_using_as_json = if options.key?(:serialize_enums_using_as_json)
+                                        options[:serialize_enums_using_as_json]
+                                      else
+                                        StoreModel.config.serialize_enums_using_as_json
+                                      end
+
+      serialize_empty_attributes = if options.key?(:serialize_empty_attributes)
+                                     options[:serialize_empty_attributes]
+                                   else
+                                     StoreModel.config.serialize_empty_attributes
+                                   end
+
+      # If the model is nested, we need to ensure that the serialization
+
+      result = @attributes.keys.each_with_object({}) do |key, values|
+        attr = @attributes.fetch(key)
+        assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json,
+                                     serialize_empty_attributes)
+        serialized = serialized_attribute(attr)
+        values[key] = serialized if serialize_empty_attributes || !serialized.nil?
+      end.with_indifferent_access
+
       result.merge!(unknown_attributes) if serialize_unknown_attributes
-      result.as_json(options)
+      result.as_json(options).tap do |json|
+        serialize_enums!(json) if serialize_enums_using_as_json
+      end
     end
 
     # Returns an Object, similar to Hash#fetch, raises
@@ -107,7 +158,7 @@ module StoreModel
     #
     # @return [String]
     def inspect
-      attribute_string = attributes.map { |name, value| "#{name}: #{value.nil? ? 'nil' : value}" }
+      attribute_string = attributes.map { |name, value| "#{name}: #{value.inspect}" }
                                    .join(", ")
       "#<#{self.class.name} #{attribute_string}>"
     end
@@ -167,6 +218,55 @@ module StoreModel
       @unknown_attributes ||= {}
     end
 
+    # Returns the value of the `@serialize_unknown_attributes` instance
+    # variable. In the current specification, unknown attributes must be
+    # persisted in the database regardless of the globally configured
+    # `serialize_unknown_attributes` option. Therefore, it returns the
+    # default value `true` if the instance variable is `nil`.
+    #
+    # This method is used to ensure that the `serialize_unknown_attributes`
+    # option is correctly applied to nested StoreModel::Model objects when
+    # the `as_json` method is called.
+    #
+    # @return [Boolean]
+    def serialize_unknown_attributes?
+      @serialize_unknown_attributes.nil? ? true : @serialize_unknown_attributes
+    end
+
+    # Returns the value of the `@serialize_enums_using_as_json` instance
+    # variable. The default value is the value of the globally configured
+    # `serialize_enums_using_as_json` option.
+    #
+    # This method is used to determine whether enums should be serialized
+    # when the `as_json` method is called in nested StoreModel::Model
+    # objects.
+    #
+    # @return [Boolean]
+    def serialize_enums_using_as_json?
+      if @serialize_enums_using_as_json.nil?
+        StoreModel.config.serialize_enums_using_as_json || false
+      else
+        @serialize_enums_using_as_json
+      end
+    end
+
+    # Returns the value of the `@serialize_empty_attributes` instance
+    # variable. The default value is the value of the globally configured
+    # `serialize_empty_attributes` option.
+    #
+    # This method is used to determine whether empty values should be serialized
+    # when the `as_json` method is called in nested StoreModel::Model
+    # objects.
+    #
+    # @return [Boolean]
+    def serialize_empty_attributes?
+      if @serialize_empty_attributes.nil?
+        StoreModel.config.serialize_empty_attributes || true
+      else
+        @serialize_empty_attributes
+      end
+    end
+
     private
 
     def attribute?(attribute)
@@ -175,5 +275,48 @@ module StoreModel
       else value.present?
       end
     end
+
+    def serialize_enums!(json)
+      enum_mappings =
+        self.class
+            .attribute_types
+            .select { |_, type| type.is_a?(StoreModel::Types::EnumType) }
+
+      enum_mappings.each_key do |name|
+        next unless json.key?(name)
+
+        json[name] = public_send(name).as_json unless json[name].nil?
+      end
+    end
+
+    def serialized_attribute(attr)
+      if attr.value.is_a? StoreModel::Model
+        Types::RawJSONEncoder.new(attr.value_for_database)
+      elsif attr.value.is_a? Array
+        serialize_array_attribute(attr.value)
+      else
+        attr.value_for_database
+      end
+    end
+
+    def serialize_array_attribute(array)
+      return array.as_json unless array.any? && array.all? { |value| value.is_a?(StoreModel::Model) }
+
+      array.as_json(
+        serialize_unknown_attributes: array.first.serialize_unknown_attributes?,
+        serialize_enums_using_as_json: array.first.serialize_enums_using_as_json?,
+        serialize_empty_attributes: array.first.serialize_empty_attributes?
+      )
+    end
+
+    def assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json, serialize_empty_attributes) # rubocop:disable Layout/LineLength
+      return unless Array(attr.value).all? { |value| value.is_a?(StoreModel::Model) }
+
+      Array(attr.value).each do |value|
+        value.serialize_unknown_attributes = serialize_unknown_attributes
+        value.serialize_enums_using_as_json = serialize_enums_using_as_json
+        value.serialize_empty_attributes = serialize_empty_attributes
+      end
+    end
   end
 end

data/lib/store_model/nested_attributes.rb

@@ -8,36 +8,96 @@ module StoreModel
     end
 
     module ClassMethods # :nodoc:
+      # gather storemodel attribute types on the class-level
+      def store_model_attribute_types
+        @store_model_attribute_types ||= {}
+      end
+
+      # add storemodel type of attribute if it is storemodel type
+      def attribute(name, type = nil, **)
+        store_model_attribute_types[name.to_s] = type if type.is_a?(Types::Base)
+        super
+      end
+
       # Enables handling of nested StoreModel::Model attributes
       #
       # @param associations [Array] list of associations and options to define attributes, for example:
       #   accepts_nested_attributes_for [:suppliers, allow_destroy: true]
       #
+      # Alternatively, use the standard Rails syntax:
+      #
+      # @param associations [Array] list of associations and attributes to define getters and setters.
+      #
+      # @param options [Hash] options not supported by StoreModel will still be passed to ActiveRecord.
+      #
       # Supported options:
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
       #   (e.g. 1, '1', true, or 'true'). This option is off by default.
-      def accepts_nested_attributes_for(*associations)
-        associations.each do |association, options|
-          case attribute_types[association.to_s]
-          when Types::One
-            define_association_setter_for_single(association, options)
-            alias_method "#{association}_attributes=", "#{association}="
-          when Types::Many
-            define_association_setter_for_many(association, options)
-          end
+      #
+      # [:reject_if]
+      #   Allows you to specify a Proc or a Symbol pointing to a method that
+      #   checks whether a record should be built for a certain attribute hash.
+      #   The hash is passed to the supplied Proc or the method and it should
+      #   return either true or false. Passing <tt>:all_blank</tt> instead of a Proc
+      #   will create a proc that will reject a record where all the attributes
+      #   are blank excluding any value for <tt>_destroy</tt>.
+      #
+      #   See https://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html#method-i-accepts_nested_attributes_for
+      def accepts_nested_attributes_for(*attributes)
+        options = attributes.extract_options!
 
-          define_attr_accessor_for_destroy(association, options)
+        attributes.each do |attribute|
+          if nested_attribute_type(attribute).is_a?(Types::Base)
+            options.reverse_merge!(allow_destroy: false, update_only: false)
+            define_store_model_attr_accessors(attribute, options)
+          else
+            super(*attribute, options)
+          end
         end
       end
 
       private
 
+      # when db connection is not available, it becomes impossible to read attributes types from
+      # ActiveModel::AttributeRegistration::ClassMethods.attribute_types, because activerecord
+      # overrides _default_attributes and triggers db connection.
+      # for activerecord model only use attribute_types if it has db connected
+      #
+      # @param attribute [String, Symbol]
+      # @return [StoreModel::Types::Base, nil]
+      def nested_attribute_type(attribute)
+        if self < ActiveRecord::Base && !schema_loaded?
+          store_model_attribute_types[attribute.to_s]
+        else
+          attribute_types[attribute.to_s]
+        end
+      end
+
+      def define_store_model_attr_accessors(attribute, options) # rubocop:disable Metrics/MethodLength
+        case nested_attribute_type(attribute)
+        when Types::OneBase
+          define_association_setter_for_single(attribute, options)
+          define_method "#{attribute}_attributes=" do |*args, **kwargs|
+            existing_model = send(attribute)
+            if existing_model && options[:update_only]
+              existing_model.assign_attributes(*args, **kwargs)
+            else
+              send("#{attribute}=", *args, **kwargs)
+            end
+          end
+        when Types::ManyBase
+          define_association_setter_for_many(attribute, options)
+        end
+
+        define_attr_accessor_for_destroy(attribute, options)
+      end
+
       def define_attr_accessor_for_destroy(association, options)
         return unless options&.dig(:allow_destroy)
 
-        attribute_types[association.to_s].model_klass.class_eval do
+        nested_attribute_type(association).model_klass.class_eval do
           attr_accessor :_destroy
         end
       end
@@ -52,7 +112,7 @@ module StoreModel
         return unless options&.dig(:allow_destroy)
 
         define_method "#{association}=" do |attributes|
-          if ActiveRecord::Type::Boolean.new.cast(attributes.stringify_keys.dig("_destroy"))
+          if ActiveRecord::Type::Boolean.new.cast(attributes.stringify_keys["_destroy"])
             super(nil)
           else
             super(attributes)
@@ -61,18 +121,32 @@ module StoreModel
       end
     end
 
-    private
+    # Base
+    def assign_nested_attributes_for_collection_association(association, attributes, options = nil)
+      return super(association, attributes) unless options
 
-    def assign_nested_attributes_for_collection_association(association, attributes, options)
       attributes = attributes.values if attributes.is_a?(Hash)
 
       if options&.dig(:allow_destroy)
         attributes.reject! do |attribute|
-          ActiveRecord::Type::Boolean.new.cast(attribute.stringify_keys.dig("_destroy"))
+          ActiveRecord::Type::Boolean.new.cast(attribute.stringify_keys["_destroy"])
         end
       end
 
+      attributes.reject! { call_store_model_reject_if(_1, options[:reject_if]) } if options&.dig(:reject_if)
+
       send("#{association}=", attributes)
     end
+
+    def call_store_model_reject_if(attributes, callback)
+      callback = ActiveRecord::NestedAttributes::ClassMethods::REJECT_ALL_BLANK_PROC if callback == :all_blank
+
+      case callback
+      when Symbol
+        method(callback).arity.zero? ? send(callback) : send(callback, attributes)
+      when Proc
+        callback.call(attributes)
+      end
+    end
   end
 end