dynamoid 3.10.0 → 3.12.1

data/lib/dynamoid/finders.rb

@@ -14,12 +14,12 @@ module Dynamoid
       # specified +raise_error: false+ option then +find+ will not raise the
       # exception.
       #
-      # When a document schema includes range key it always should be specified
+      # When a document schema includes range key it should always be specified
       # in +find+ method call. In case it's missing +MissingRangeKey+ exception
       # will be raised.
       #
       # Please note that +find+ doesn't preserve order of models in result when
-      # passes multiple ids.
+      # given multiple ids.
       #
       # Supported following options:
       # * +consistent_read+
@@ -78,7 +78,7 @@ module Dynamoid
       #   # Find all the tweets using hash key and range key with consistent read
       #   Tweet.find_all([['1', 'red'], ['1', 'green']], consistent_read: true)
       def find_all(ids, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all is deprecated! Call .find instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all is deprecated! Call .find instead of')
 
         _find_all(ids, options)
       end
@@ -100,21 +100,35 @@ module Dynamoid
       #
       # @since 0.2.0
       def find_by_id(id, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_by_id is deprecated! Call .find instead of', caller[1..-1])
+        Dynamoid.deprecator.warn('[Dynamoid] .find_by_id is deprecated! Call .find instead of')
 
         _find_by_id(id, options)
       end
 
       # @private
       def _find_all(ids, options = {})
-        raise Errors::MissingRangeKey if range_key && ids.any? { |_pk, sk| sk.nil? }
-
-        if range_key
-          ids = ids.map do |pk, sk|
-            sk_casted = TypeCasting.cast_field(sk, attributes[range_key])
-            sk_dumped = Dumping.dump_field(sk_casted, attributes[range_key])
+        ids = ids.map do |id|
+          if range_key
+            # expect [hash key, range key] pair
+            pk, sk = id
+
+            if pk.nil?
+              raise Errors::MissingHashKey
+            end
+            if sk.nil?
+              raise Errors::MissingRangeKey
+            end
+
+            pk_dumped = cast_and_dump(hash_key, pk)
+            sk_dumped = cast_and_dump(range_key, sk)
+
+            [pk_dumped, sk_dumped]
+          else
+            if id.nil?
+              raise Errors::MissingHashKey
+            end
 
-            [pk, sk_dumped]
+            cast_and_dump(hash_key, id)
           end
         end
 
@@ -144,7 +158,7 @@ module Dynamoid
           models.each { |m| m.run_callbacks :find }
           models
         else
-          ids_list = range_key ? ids.map { |pk, sk| "(#{pk},#{sk})" } : ids.map(&:to_s)
+          ids_list = range_key ? ids.map { |pk, sk| "(#{pk.inspect},#{sk.inspect})" } : ids.map(&:inspect)
           message = "Couldn't find all #{name.pluralize} with primary keys [#{ids_list.join(', ')}] "
           message += "(found #{items.size} results, but was looking for #{ids.size})"
           raise Errors::RecordNotFound, message
@@ -153,22 +167,21 @@ module Dynamoid
 
       # @private
       def _find_by_id(id, options = {})
+        raise Errors::MissingHashKey if id.nil?
         raise Errors::MissingRangeKey if range_key && options[:range_key].nil?
 
-        if range_key
-          key = options[:range_key]
-          key_casted = TypeCasting.cast_field(key, attributes[range_key])
-          key_dumped = Dumping.dump_field(key_casted, attributes[range_key])
+        partition_key_dumped = cast_and_dump(hash_key, id)
 
-          options[:range_key] = key_dumped
+        if range_key
+          options[:range_key] = cast_and_dump(range_key, options[:range_key])
         end
 
-        if item = Dynamoid.adapter.read(table_name, id, options.slice(:range_key, :consistent_read))
+        if item = Dynamoid.adapter.read(table_name, partition_key_dumped, options.slice(:range_key, :consistent_read))
           model = from_database(item)
           model.run_callbacks :find
           model
         elsif options[:raise_error]
-          primary_key = range_key ? "(#{id},#{options[:range_key]})" : id
+          primary_key = range_key ? "(#{id.inspect},#{options[:range_key].inspect})" : id.inspect
           message = "Couldn't find #{name} with primary key #{primary_key}"
           raise Errors::RecordNotFound, message
         end
@@ -180,7 +193,7 @@ module Dynamoid
       # @param range_key [Scalar value] range key of the object to find
       #
       def find_by_composite_key(hash_key, range_key, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_by_composite_key is deprecated! Call .find instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_by_composite_key is deprecated! Call .find instead of')
 
         _find_by_id(hash_key, options.merge(range_key: range_key))
       end
@@ -207,7 +220,7 @@ module Dynamoid
       #
       # @return [Array] an array of all matching items
       def find_all_by_composite_key(hash_key, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all_composite_key is deprecated! Call .where instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all_composite_key is deprecated! Call .where instead of')
 
         Dynamoid.adapter.query(table_name, options.merge(hash_value: hash_key)).flat_map { |i| i }.collect do |item|
           from_database(item)
@@ -237,7 +250,7 @@ module Dynamoid
       # @param options [Hash] conditions on range key e.g. +{ "rank.lte": 10 }, query filter, projected keys, scan_index_forward etc.
       # @return [Array] an array of all matching items
       def find_all_by_secondary_index(hash, options = {})
-        ActiveSupport::Deprecation.warn('[Dynamoid] .find_all_by_secondary_index is deprecated! Call .where instead of')
+        Dynamoid.deprecator.warn('[Dynamoid] .find_all_by_secondary_index is deprecated! Call .where instead of')
 
         range = options[:range] || {}
         hash_key_field, hash_key_value = hash.first
@@ -291,7 +304,7 @@ module Dynamoid
       def method_missing(method, *args)
         # Cannot use Symbol#start_with? because it was introduced in Ruby 2.7, but we support Ruby >= 2.3
         if method.to_s.start_with?('find')
-          ActiveSupport::Deprecation.warn("[Dynamoid] .#{method} is deprecated! Call .where instead of")
+          Dynamoid.deprecator.warn("[Dynamoid] .#{method} is deprecated! Call .where instead of")
 
           finder = method.to_s.split('_by_').first
           attributes = method.to_s.split('_by_').last.split('_and_')
@@ -308,6 +321,14 @@ module Dynamoid
           super
         end
       end
+
+      private
+
+      def cast_and_dump(name, value)
+        attribute_options = attributes[name]
+        casted_value = TypeCasting.cast_field(value, attribute_options)
+        Dumping.dump_field(casted_value, attribute_options)
+      end
     end
   end
 end

data/lib/dynamoid/loadable.rb

@@ -11,6 +11,7 @@ module Dynamoid
 
       self
     end
+    alias assign_attributes load
 
     # Reload an object from the database -- if you suspect the object has changed in the data store and you need those
     # changes to be reflected immediately, you would call this method. This is a consistent read.

data/lib/dynamoid/persistence/inc.rb

@@ -1,56 +1,66 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_casting_and_dumping'
+
 module Dynamoid
   module Persistence
     # @private
     class Inc
-      def self.call(model_class, hash_key, range_key = nil, counters)
-        new(model_class, hash_key, range_key, counters).call
+      def self.call(model_class, partition_key, sort_key = nil, counters)
+        new(model_class, partition_key, sort_key, counters).call
       end
 
       # rubocop:disable Style/OptionalArguments
-      def initialize(model_class, hash_key, range_key = nil, counters)
+      def initialize(model_class, partition_key, sort_key = nil, counters)
         @model_class = model_class
-        @hash_key = hash_key
-        @range_key = range_key
+        @partition_key = partition_key
+        @sort_key = sort_key
         @counters = counters
       end
       # rubocop:enable Style/OptionalArguments
 
       def call
         touch = @counters.delete(:touch)
+        partition_key_dumped = cast_and_dump(@model_class.hash_key, @partition_key)
+        options = update_item_options(partition_key_dumped)
+
+        Dynamoid.adapter.update_item(@model_class.table_name, partition_key_dumped, options) do |t|
+          item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
 
-        Dynamoid.adapter.update_item(@model_class.table_name, @hash_key, update_item_options) do |t|
           @counters.each do |name, value|
-            t.add(name => cast_and_dump_attribute_value(name, value))
+            item_updater.add(name => value)
           end
 
           if touch
             value = DateTime.now.in_time_zone(Time.zone)
 
             timestamp_attributes_to_touch(touch).each do |name|
-              t.set(name => cast_and_dump_attribute_value(name, value))
+              item_updater.set(name => value)
             end
           end
         end
+      rescue Dynamoid::Errors::ConditionalCheckFailedException # rubocop:disable Lint/SuppressedException
       end
 
       private
 
-      def update_item_options
+      def update_item_options(partition_key_dumped)
+        options = {}
+
+        conditions = {
+          if: {
+            @model_class.hash_key => partition_key_dumped
+          }
+        }
+        options[:conditions] = conditions
+
         if @model_class.range_key
-          range_key_options = @model_class.attributes[@model_class.range_key]
-          value_casted = TypeCasting.cast_field(@range_key, range_key_options)
-          value_dumped = Dumping.dump_field(value_casted, range_key_options)
-          { range_key: value_dumped }
-        else
-          {}
+          sort_key_dumped = cast_and_dump(@model_class.range_key, @sort_key)
+          options[:range_key] = sort_key_dumped
+          options[:conditions][@model_class.range_key] = sort_key_dumped
         end
-      end
 
-      def cast_and_dump_attribute_value(name, value)
-        value_casted = TypeCasting.cast_field(value, @model_class.attributes[name])
-        Dumping.dump_field(value_casted, @model_class.attributes[name])
+        options
       end
 
       def timestamp_attributes_to_touch(touch)
@@ -61,6 +71,12 @@ module Dynamoid
         names += Array.wrap(touch) if touch != true
         names
       end
+
+      def cast_and_dump(name, value)
+        options = @model_class.attributes[name]
+        value_casted = TypeCasting.cast_field(value, options)
+        Dumping.dump_field(value_casted, options)
+      end
     end
   end
 end

data/lib/dynamoid/persistence/item_updater_with_casting_and_dumping.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Persistence
+    # @private
+    class ItemUpdaterWithCastingAndDumping
+      def initialize(model_class, item_updater)
+        @model_class = model_class
+        @item_updater = item_updater
+      end
+
+      def add(attributes)
+        @item_updater.add(cast_and_dump(attributes))
+      end
+
+      def set(attributes)
+        @item_updater.set(cast_and_dump(attributes))
+      end
+
+      private
+
+      def cast_and_dump(attributes)
+        casted_and_dumped = {}
+
+        attributes.each do |name, value|
+          value_casted = TypeCasting.cast_field(value, @model_class.attributes[name])
+          value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[name])
+
+          casted_and_dumped[name] = value_dumped
+        end
+
+        casted_and_dumped
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence/item_updater_with_dumping.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Persistence
+    # @private
+    class ItemUpdaterWithDumping
+      def initialize(model_class, item_updater)
+        @model_class = model_class
+        @item_updater = item_updater
+      end
+
+      def add(attributes)
+        @item_updater.add(dump(attributes))
+      end
+
+      def set(attributes)
+        @item_updater.set(dump(attributes))
+      end
+
+      private
+
+      def dump(attributes)
+        dumped = {}
+
+        attributes.each do |name, value|
+          dumped[name] = Dumping.dump_field(value, @model_class.attributes[name])
+        end
+
+        dumped
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence/save.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -10,10 +12,12 @@ module Dynamoid
 
       def initialize(model, touch: nil)
         @model = model
-        @touch = touch # touch=false means explicit disabling of updating the `updated_at` attribute
+        @touch = touch # `touch: false` means explicit disabling of updating the `updated_at` attribute
       end
 
       def call
+        validate_primary_key!
+
         @model.hash_key = SecureRandom.uuid if @model.hash_key.blank?
 
         return true unless @model.changed?
@@ -34,11 +38,14 @@ module Dynamoid
           Dynamoid.adapter.write(@model.class.table_name, attributes_dumped, conditions_for_write)
         else
           attributes_to_persist = @model.attributes.slice(*@model.changed.map(&:to_sym))
+          partition_key_dumped = dump(@model.class.hash_key, @model.hash_key)
+          options = options_to_update_item(partition_key_dumped)
+
+          Dynamoid.adapter.update_item(@model.class.table_name, partition_key_dumped, options) do |t|
+            item_updater = ItemUpdaterWithDumping.new(@model.class, t)
 
-          Dynamoid.adapter.update_item(@model.class.table_name, @model.hash_key, options_to_update_item) do |t|
             attributes_to_persist.each do |name, value|
-              value_dumped = Dumping.dump_field(value, @model.class.attributes[name])
-              t.set(name => value_dumped)
+              item_updater.set(name => value)
             end
           end
         end
@@ -55,22 +62,25 @@ module Dynamoid
 
       private
 
+      def validate_primary_key!
+        raise Dynamoid::Errors::MissingHashKey if !@model.new_record? && @model.hash_key.nil?
+        raise Dynamoid::Errors::MissingRangeKey if @model.class.range_key? && @model.range_value.nil?
+      end
+
       # Should be called after incrementing `lock_version` attribute
       def conditions_for_write
         conditions = {}
 
         # Add an 'exists' check to prevent overwriting existing records with new ones
-        if @model.new_record?
-          conditions[:unless_exists] = [@model.class.hash_key]
-          if @model.range_key
-            conditions[:unless_exists] << @model.range_key
-          end
+        conditions[:unless_exists] = [@model.class.hash_key]
+        if @model.range_key
+          conditions[:unless_exists] << @model.range_key
         end
 
         # Add an optimistic locking check if the lock_version column exists
         # Uses the original lock_version value from Dirty API
         # in case user changed 'lock_version' manually
-        if @model.class.attributes[:lock_version] && (@model.changes[:lock_version][0])
+        if @model.class.attributes[:lock_version] && @model.changes[:lock_version][0]
           conditions[:if] ||= {}
           conditions[:if][:lock_version] = @model.changes[:lock_version][0]
         end
@@ -78,22 +88,22 @@ module Dynamoid
         conditions
       end
 
-      def options_to_update_item
+      def options_to_update_item(partition_key_dumped)
         options = {}
 
         if @model.class.range_key
-          value_dumped = Dumping.dump_field(@model.range_value, @model.class.attributes[@model.class.range_key])
+          value_dumped = dump(@model.class.range_key, @model.range_value)
           options[:range_key] = value_dumped
         end
 
         conditions = {}
         conditions[:if] ||= {}
-        conditions[:if][@model.class.hash_key] = @model.hash_key
+        conditions[:if][@model.class.hash_key] = partition_key_dumped
 
         # Add an optimistic locking check if the lock_version column exists
         # Uses the original lock_version value from Dirty API
         # in case user changed 'lock_version' manually
-        if @model.class.attributes[:lock_version] && (@model.changes[:lock_version][0])
+        if @model.class.attributes[:lock_version] && @model.changes[:lock_version][0]
           conditions[:if] ||= {}
           conditions[:if][:lock_version] = @model.changes[:lock_version][0]
         end
@@ -102,6 +112,11 @@ module Dynamoid
 
         options
       end
+
+      def dump(name, value)
+        options = @model.class.attributes[name]
+        Dumping.dump_field(value, options)
+      end
     end
   end
 end

data/lib/dynamoid/persistence/update_fields.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_casting_and_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -14,9 +16,12 @@ module Dynamoid
         @sort_key = sort_key
         @attributes = attributes.symbolize_keys
         @conditions = conditions
+
+        @partition_key_dumped = cast_and_dump(@model_class.hash_key, @partition_key)
       end
 
       def call
+        validate_primary_key!
         UpdateValidations.validate_attributes_exist(@model_class, @attributes)
 
         if @model_class.timestamps_enabled?
@@ -30,12 +35,17 @@ module Dynamoid
 
       private
 
+      def validate_primary_key!
+        raise Dynamoid::Errors::MissingHashKey if @partition_key.nil?
+        raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @sort_key.nil?
+      end
+
       def update_item
-        Dynamoid.adapter.update_item(@model_class.table_name, @partition_key, options_to_update_item) do |t|
+        Dynamoid.adapter.update_item(@model_class.table_name, @partition_key_dumped, options_to_update_item) do |t|
+          item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
+
           @attributes.each do |k, v|
-            value_casted = TypeCasting.cast_field(v, @model_class.attributes[k])
-            value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[k])
-            t.set(k => value_dumped)
+            item_updater.set(k => v)
           end
         end
       end
@@ -48,18 +58,23 @@ module Dynamoid
         options = {}
 
         if @model_class.range_key
-          value_casted = TypeCasting.cast_field(@sort_key, @model_class.attributes[@model_class.range_key])
-          value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[@model_class.range_key])
-          options[:range_key] = value_dumped
+          range_key_dumped = cast_and_dump(@model_class.range_key, @sort_key)
+          options[:range_key] = range_key_dumped
         end
 
         conditions = @conditions.deep_dup
         conditions[:if] ||= {}
-        conditions[:if][@model_class.hash_key] = @partition_key
+        conditions[:if][@model_class.hash_key] = @partition_key_dumped
         options[:conditions] = conditions
 
         options
       end
+
+      def cast_and_dump(name, value)
+        options = @model_class.attributes[name]
+        value_casted = TypeCasting.cast_field(value, options)
+        Dumping.dump_field(value_casted, options)
+      end
     end
   end
 end

data/lib/dynamoid/persistence/update_validations.rb

@@ -7,9 +7,9 @@ module Dynamoid
       def self.validate_attributes_exist(model_class, attributes)
         model_attributes = model_class.attributes.keys
 
-        attributes.each_key do |attr_name|
-          unless model_attributes.include?(attr_name)
-            raise Dynamoid::Errors::UnknownAttribute, "Attribute #{attr_name} does not exist in #{model_class}"
+        attributes.each_key do |name|
+          unless model_attributes.include?(name)
+            raise Dynamoid::Errors::UnknownAttribute.new(model_class, name)
           end
         end
       end

data/lib/dynamoid/persistence/upsert.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'item_updater_with_casting_and_dumping'
+
 module Dynamoid
   module Persistence
     # @private
@@ -17,6 +19,7 @@ module Dynamoid
       end
 
       def call
+        validate_primary_key!
         UpdateValidations.validate_attributes_exist(@model_class, @attributes)
 
         if @model_class.timestamps_enabled?
@@ -30,13 +33,19 @@ module Dynamoid
 
       private
 
+      def validate_primary_key!
+        raise Dynamoid::Errors::MissingHashKey if @partition_key.nil?
+        raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @sort_key.nil?
+      end
+
       def update_item
-        Dynamoid.adapter.update_item(@model_class.table_name, @partition_key, options_to_update_item) do |t|
-          @attributes.each do |k, v|
-            value_casted = TypeCasting.cast_field(v, @model_class.attributes[k])
-            value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[k])
+        partition_key_dumped = cast_and_dump(@model_class.hash_key, @partition_key)
 
-            t.set(k => value_dumped)
+        Dynamoid.adapter.update_item(@model_class.table_name, partition_key_dumped, options_to_update_item) do |t|
+          item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
+
+          @attributes.each do |k, v|
+            item_updater.set(k => v)
           end
         end
       end
@@ -45,9 +54,8 @@ module Dynamoid
         options = {}
 
         if @model_class.range_key
-          value_casted = TypeCasting.cast_field(@sort_key, @model_class.attributes[@model_class.range_key])
-          value_dumped = Dumping.dump_field(value_casted, @model_class.attributes[@model_class.range_key])
-          options[:range_key] = value_dumped
+          range_key_dumped = cast_and_dump(@model_class.range_key, @sort_key)
+          options[:range_key] = range_key_dumped
         end
 
         options[:conditions] = @conditions
@@ -57,6 +65,12 @@ module Dynamoid
       def undump_attributes(raw_attributes)
         Undumping.undump_attributes(raw_attributes, @model_class.attributes)
       end
+
+      def cast_and_dump(name, value)
+        options = @model_class.attributes[name]
+        value_casted = TypeCasting.cast_field(value, options)
+        Dumping.dump_field(value_casted, options)
+      end
     end
   end
 end