store_model 1.6.1 → 4.4.0

data/lib/store_model/railtie.rb

@@ -7,8 +7,10 @@ module StoreModel # :nodoc:
   class Railtie < Rails::Railtie # :nodoc:
     config.to_prepare do |_app|
       ActiveSupport.on_load(:active_record) do
-        ActiveModel::Attributes.prepend(Attributes)
-        prepend(Base)
+        if StoreModel.config.enable_parent_assignment
+          ActiveModel::Attributes.prepend(Attributes)
+          prepend(Base)
+        end
       end
     end
   end

data/lib/store_model/type_builders.rb

@@ -14,5 +14,11 @@ module StoreModel
     def to_array_type
       Types::Many.new(self)
     end
+
+    # Converts StoreModel::Model to Types::Hash
+    # @return [Types::Hash]
+    def to_hash_type
+      Types::Hash.new(self)
+    end
   end
 end

data/lib/store_model/types/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Base type for StoreModel::Model
+    class Base < ActiveModel::Type::Value
+      attr_reader :model_klass
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        raise NotImplementedError
+      end
+
+      protected
+
+      def raise_cast_error(_value)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/store_model/types/enum_type.rb

@@ -11,8 +11,10 @@ module StoreModel
       # @param mapping [Hash] mapping for enum values
       #
       # @return [StoreModel::Types::EnumType]
-      def initialize(mapping)
+      def initialize(mapping, raise_on_invalid_values)
         @mapping = mapping
+        @raise_on_invalid_values = raise_on_invalid_values
+        super()
       end
 
       # Returns type
@@ -31,8 +33,8 @@ module StoreModel
         return if value.blank?
 
         case value
-        when String, Symbol then cast_symbol_value(value.to_sym)
-        when Integer then cast_integer_value(value)
+        when String, Symbol then cast_symbol_value(value)
+        when Integer, Float then cast_integer_value(value)
         else
           raise StoreModel::Types::CastError,
                 "failed casting #{value.inspect}, only String, Symbol or " \
@@ -43,12 +45,12 @@ module StoreModel
       private
 
       def cast_symbol_value(value)
-        raise_invalid_value!(value) unless @mapping.key?(value.to_sym)
-        @mapping[value.to_sym]
+        raise_invalid_value!(value) if @raise_on_invalid_values && !@mapping.key?(value.to_sym)
+        @mapping[value.to_sym] || value
       end
 
       def cast_integer_value(value)
-        raise_invalid_value!(value) unless @mapping.value?(value)
+        raise_invalid_value!(value) if @raise_on_invalid_values && !@mapping.value?(value)
         value
       end
 

data/lib/store_model/types/hash.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling a hash of
+    # StoreModel::Model
+    class Hash < HashBase
+      # Initializes type for model class
+      #
+      # @param model_klass [StoreModel::Model] model class to handle
+      #
+      # @return [StoreModel::Types::Hash]
+      def initialize(model_klass)
+        @model_klass = model_klass
+        super()
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :hash
+      end
+
+      protected
+
+      def ensure_model_class(hash)
+        return {} unless hash.is_a?(::Hash)
+
+        hash.transform_values do |object|
+          next object if object.nil?
+
+          object.is_a?(@model_klass) ? object : cast_model_type_value(object)
+        end
+      end
+
+      def cast_model_type_value(value)
+        model_klass_type.cast_value(value)
+      end
+
+      def model_klass_type
+        @model_klass_type ||= @model_klass.to_type
+      end
+
+      def raise_cast_error(value)
+        raise StoreModel::Types::CastError,
+              "failed casting #{value.inspect}, only String or Hash instances are allowed"
+      end
+    end
+  end
+end

data/lib/store_model/types/hash_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements type for handling a hash of StoreModel::Model
+    class HashBase < Base
+      # Casts +value+ from DB or user to Hash of StoreModel::Model instances
+      #
+      # @param value [Object] a value to cast
+      #
+      # @return Hash
+      def cast_value(value)
+        case value
+        when String then decode_and_initialize(value)
+        when ::Hash then ensure_model_class(value)
+        when nil then value
+        else
+          raise_cast_error(value)
+        end
+      end
+
+      # Casts a value from the ruby type to a type that the database knows how
+      # to understand.
+      #
+      # @param value [Object] value to serialize
+      #
+      # @return [String] serialized value
+      def serialize(value)
+        return super unless value.is_a?(::Hash)
+        if value.empty? || value.values.any? { |v| !v.is_a?(StoreModel::Model) }
+          return ActiveSupport::JSON.encode(value)
+        end
+
+        ActiveSupport::JSON.encode(
+          value,
+          serialize_unknown_attributes: value.values.first.serialize_unknown_attributes?,
+          serialize_enums_using_as_json: value.values.first.serialize_enums_using_as_json?
+        )
+      end
+
+      # Determines whether the mutable value has been modified since it was read
+      #
+      # @param raw_old_value [Object] old value
+      # @param new_value [Object] new value
+      #
+      # @return [Boolean]
+      def changed_in_place?(raw_old_value, new_value)
+        cast_value(raw_old_value) != new_value
+      end
+
+      protected
+
+      def ensure_model_class(_hash)
+        raise NotImplementedError
+      end
+
+      def cast_model_type_value(_value)
+        raise NotImplementedError
+      end
+
+      private
+
+      # rubocop:disable Style/RescueModifier
+      def decode_and_initialize(hash_value)
+        decoded = ActiveSupport::JSON.decode(hash_value) rescue {}
+        return {} unless decoded.is_a?(::Hash)
+
+        decoded.transform_values do |attributes|
+          next nil if attributes.nil?
+
+          cast_model_type_value(attributes)
+        end
+      end
+      # rubocop:enable Style/RescueModifier
+    end
+  end
+end

data/lib/store_model/types/hash_polymorphic.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling a hash of
+    # polymorphic StoreModel::Model
+    class HashPolymorphic < HashBase
+      include PolymorphicHelper
+
+      # Initializes type for model class
+      #
+      # @param model_wrapper [Proc] proc that returns class based on value
+      #
+      # @return [StoreModel::Types::HashPolymorphic]
+      def initialize(model_wrapper)
+        @model_wrapper = model_wrapper
+        super()
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :polymorphic_hash
+      end
+
+      protected
+
+      def ensure_model_class(hash)
+        return {} unless hash.is_a?(::Hash)
+
+        hash.transform_values do |object|
+          next object if object.nil?
+          next object if implements_model?(object.class)
+
+          cast_model_type_value(object)
+        end
+      end
+
+      def cast_model_type_value(value)
+        model_klass = @model_wrapper.call(value)
+
+        raise_extract_wrapper_error(model_klass) unless implements_model?(model_klass)
+
+        model_klass.to_type.cast_value(value)
+      end
+
+      def raise_cast_error(value)
+        raise StoreModel::Types::CastError,
+              "failed casting #{value.inspect}, only String, " \
+              "Hash or instances which implement StoreModel::Model are allowed"
+      end
+    end
+  end
+end

data/lib/store_model/types/many.rb

@@ -14,6 +14,7 @@ module StoreModel
       # @return [StoreModel::Types::Many]
       def initialize(model_klass)
         @model_klass = model_klass
+        super()
       end
 
       # Returns type

data/lib/store_model/types/many_base.rb

@@ -4,18 +4,8 @@ require "active_model"
 
 module StoreModel
   module Types
-    # Implements ActiveModel::Type::Value type for handling an array of
-    # StoreModel::Model
-    class ManyBase < ActiveModel::Type::Value
-      attr_reader :model_klass
-
-      # Returns type
-      #
-      # @return [Symbol]
-      def type
-        raise NotImplementedError
-      end
-
+    # Implements type for handling an array of StoreModel::Model
+    class ManyBase < Base
       # Casts +value+ from DB or user to StoreModel::Model instance
       #
       # @param value [Object] a value to cast
@@ -40,7 +30,11 @@ module StoreModel
       def serialize(value)
         case value
         when Array
-          ActiveSupport::JSON.encode(value, serialize_unknown_attributes: true)
+          return ActiveSupport::JSON.encode(value) if value.empty? || value.any? { |v| !v.is_a?(StoreModel::Model) }
+
+          ActiveSupport::JSON.encode(value,
+                                     serialize_unknown_attributes: value.first.serialize_unknown_attributes?,
+                                     serialize_enums_using_as_json: value.first.serialize_enums_using_as_json?)
         else
           super
         end
@@ -66,10 +60,6 @@ module StoreModel
         raise NotImplementedError
       end
 
-      def raise_cast_error(_value)
-        raise NotImplementedError
-      end
-
       private
 
       # rubocop:disable Style/RescueModifier

data/lib/store_model/types/many_polymorphic.rb

@@ -16,6 +16,7 @@ module StoreModel
       # @return [StoreModel::Types::PolymorphicArrayType ]
       def initialize(model_wrapper)
         @model_wrapper = model_wrapper
+        super()
       end
 
       # Returns type

data/lib/store_model/types/one.rb

@@ -13,6 +13,7 @@ module StoreModel
       # @return [StoreModel::Types::One]
       def initialize(model_klass)
         @model_klass = model_klass
+        super()
       end
 
       # Returns type
@@ -27,12 +28,17 @@ module StoreModel
       # @param value [Object] a value to cast
       #
       # @return StoreModel::Model
-      def cast_value(value)
-        case value
-        when String then decode_and_initialize(value)
-        when Hash then model_instance(value)
-        when @model_klass, nil then value
-        else raise_cast_error(value)
+      def cast_value(value) # rubocop:disable Metrics/MethodLength
+        return nil if value.nil?
+
+        if value.is_a?(String)
+          decode_and_initialize(value)
+        elsif value.is_a?(@model_klass)
+          value
+        elsif value.respond_to?(:to_h) # Hash itself included
+          model_instance(value.to_h)
+        else
+          raise_cast_error(value)
         end
       rescue ActiveModel::UnknownAttributeError => e
         handle_unknown_attribute(value, e)
@@ -46,13 +52,38 @@ module StoreModel
       # @return [String] serialized value
       def serialize(value)
         case value
-        when Hash, @model_klass
-          ActiveSupport::JSON.encode(value, serialize_unknown_attributes: true)
+        when @model_klass
+          ActiveSupport::JSON.encode(value,
+                                     serialize_unknown_attributes: value.serialize_unknown_attributes?,
+                                     serialize_enums_using_as_json: value.serialize_enums_using_as_json?)
+        when ::Hash
+          ActiveSupport::JSON.encode(value)
         else
           super
         end
       end
 
+      # Converts a value from database input to the appropriate ruby type.
+      #
+      # @param value [String] value to deserialize
+      #
+      # @return [Object] deserialized value
+
+      # rubocop:disable Style/RescueModifier
+      def deserialize(value)
+        case value
+        when String
+          payload = ActiveSupport::JSON.decode(value) rescue {}
+          model_instance(deserialize_by_types(payload))
+        when ::Hash
+          model_instance(deserialize_by_types(value))
+        when nil
+          nil
+        else raise_cast_error(value)
+        end
+      end
+      # rubocop:enable Style/RescueModifier
+
       private
 
       def raise_cast_error(value)
@@ -63,6 +94,14 @@ module StoreModel
 
       def model_instance(value)
         @model_klass.new(value)
+      rescue ActiveModel::UnknownAttributeError => e
+        handle_unknown_attribute(value, e)
+      end
+
+      def deserialize_by_types(hash)
+        @model_klass.attribute_types.each.with_object(hash.dup) do |(key, type), value|
+          value[key] = type.deserialize(hash[key]) if hash.key?(key)
+        end
       end
     end
   end

data/lib/store_model/types/one_base.rb

@@ -4,17 +4,8 @@ require "active_model"
 
 module StoreModel
   module Types
-    # Implements ActiveModel::Type::Value type for handling an instance of StoreModel::Model
-    class OneBase < ActiveModel::Type::Value
-      attr_reader :model_klass
-
-      # Returns type
-      #
-      # @return [Symbol]
-      def type
-        raise NotImplementedError
-      end
-
+    # Implements type for handling an instance of StoreModel::Model
+    class OneBase < Base
       # Casts +value+ from DB or user to StoreModel::Model instance
       #
       # @param value [Object] a value to cast
@@ -36,10 +27,6 @@ module StoreModel
 
       protected
 
-      def raise_cast_error(_value)
-        raise NotImplementedError
-      end
-
       def model_instance(_value)
         raise NotImplementedError
       end

data/lib/store_model/types/one_of.rb

@@ -18,6 +18,10 @@ module StoreModel
       def to_array_type
         Types::ManyPolymorphic.new(@block)
       end
+
+      def to_hash_type
+        Types::HashPolymorphic.new(@block)
+      end
     end
   end
 end

data/lib/store_model/types/one_polymorphic.rb

@@ -15,6 +15,7 @@ module StoreModel
       # @return [StoreModel::Types::OnePolymorphic ]
       def initialize(model_wrapper)
         @model_wrapper = model_wrapper
+        super()
       end
 
       # Returns type
@@ -29,15 +30,17 @@ module StoreModel
       # @param value [Object] a value to cast
       #
       # @return StoreModel::Model
-      def cast_value(value)
-        case value
-        when String then decode_and_initialize(value)
-        when Hash then extract_model_klass(value).new(value)
-        when nil then value
-        else
-          raise_cast_error(value) unless value.class.ancestors.include?(StoreModel::Model)
+      def cast_value(value) # rubocop:disable Metrics/MethodLength
+        return nil if value.nil?
 
+        if value.is_a?(String)
+          decode_and_initialize(value)
+        elsif value.class.ancestors.include?(StoreModel::Model)
           value
+        elsif value.respond_to?(:to_h) # Hash itself included
+          extract_model_klass(value).to_type.cast_value(value.to_h)
+        else
+          raise_cast_error(value)
         end
       rescue ActiveModel::UnknownAttributeError => e
         handle_unknown_attribute(value, e)
@@ -50,9 +53,17 @@ module StoreModel
       #
       # @return [String] serialized value
       def serialize(value)
-        return super unless value.is_a?(Hash) || implements_model?(value.class)
+        return super unless value.is_a?(::Hash) || implements_model?(value.class)
 
-        ActiveSupport::JSON.encode(value, serialize_unknown_attributes: true)
+        if value.is_a?(StoreModel::Model)
+          ActiveSupport::JSON.encode(
+            value,
+            serialize_unknown_attributes: value.serialize_unknown_attributes?,
+            serialize_enums_using_as_json: value.serialize_enums_using_as_json?
+          )
+        else
+          ActiveSupport::JSON.encode(value)
+        end
       end
 
       protected

data/lib/store_model/types/raw_json.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module StoreModel
+  module Types
+    # Implements #encode_json and #as_json methods.
+    # By wrapping serialized objects in this type, it prevents duplicate
+    # JSON serialization passes on nested object. It is named as Encoder
+    # as it will not work to inflate typed attributes and is intended
+    # to be used internally.
+    class RawJSONEncoder < String
+      def encode_json(_encoder)
+        self
+      end
+
+      def as_json(_options = nil)
+        JSON.parse(self)
+      end
+    end
+  end
+end

data/lib/store_model/types.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "store_model/types/polymorphic_helper"
+require "store_model/types/base"
 
 require "store_model/types/one_base"
 require "store_model/types/one"
@@ -10,10 +11,16 @@ require "store_model/types/many_base"
 require "store_model/types/many"
 require "store_model/types/many_polymorphic"
 
+require "store_model/types/hash_base"
+require "store_model/types/hash"
+require "store_model/types/hash_polymorphic"
+
 require "store_model/types/enum_type"
 
 require "store_model/types/one_of"
 
+require "store_model/types/raw_json"
+
 module StoreModel
   # Contains all custom types.
   module Types

data/lib/store_model/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StoreModel # :nodoc:
-  VERSION = "1.6.1"
+  VERSION = "4.4.0"
 end

data/lib/store_model.rb

@@ -15,5 +15,61 @@ module StoreModel # :nodoc:
     def one_of(&block)
       Types::OneOf.new(&block)
     end
+
+    # Creates a union type for polymorphic attributes
+    # @param klasses [Array<Class>] array of classes that can be used
+    # @param discriminator [String, Symbol] the attribute key to check for type (default: 'type')
+    # @return instance [Types::OneOf]
+    def union(klasses, discriminator: "type")
+      discriminators_and_classes = klasses.map do |cls|
+        [cls._default_attributes[discriminator]&.value, cls]
+      end
+
+      validate_missing_discriminators!(discriminator, discriminators_and_classes)
+      validate_duplicate_discriminators!(discriminators_and_classes)
+
+      union_one_of(discriminator, Hash[discriminators_and_classes])
+    end
+
+    private
+
+    def validate_missing_discriminators!(discriminator, discriminators_and_classes)
+      missing_discriminator_classes = discriminators_and_classes.select do |(discriminator_value, _cls)|
+        discriminator_value.blank?
+      end.map(&:last)
+
+      return if missing_discriminator_classes.empty?
+
+      raise "discriminator_attribute not set for #{discriminator} on #{missing_discriminator_classes.join(', ')}"
+    end
+
+    def validate_duplicate_discriminators!(discriminators_and_classes)
+      discriminator_counts = discriminators_and_classes.group_by(&:first)
+      duplicates = discriminator_counts.select { |_discriminator_value, pairs| pairs.length > 1 }
+
+      return if duplicates.empty?
+
+      duplicate_messages = duplicates.map do |discriminator_value, pairs|
+        classes = pairs.map(&:last).map(&:name).join(", ")
+        "#{discriminator_value.inspect} => [#{classes}]"
+      end
+
+      raise "Duplicate discriminator values found: #{duplicate_messages.join('; ')}"
+    end
+
+    def union_one_of(discriminator, class_map)
+      Types::OneOf.new do |attributes|
+        next nil unless attributes
+
+        discriminator_value = attributes.with_indifferent_access[discriminator]
+
+        raise ArgumentError, "Missing discriminator attribute #{discriminator} for union" if discriminator_value.blank?
+
+        cls = class_map[discriminator_value]
+        raise ArgumentError, "Unknown discriminator value for union: #{discriminator_value}" if cls.blank?
+
+        cls
+      end
+    end
   end
 end