dynamoid 3.13.1 → 3.14.0

data/lib/dynamoid/transactions/mutation/increment.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'inc'
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class Increment < Base
+        def initialize(model, attribute, by, touch: nil)
+          super()
+
+          @model = model
+          @attribute = attribute
+          @by = by
+          @touch = touch
+          @action_requests = [] # will be filled in later with Inc#action_requests
+        end
+
+        def on_registration
+          @model.run_callbacks(:touch) do
+            @model.increment(@attribute, @by)
+            change = @model.read_attribute(@attribute) - (@model.send(:attribute_was, @attribute) || 0)
+
+            inc_action = Inc.new(@model.class, @model.hash_key, @model.range_value, { @attribute => change, touch: @touch })
+            inc_action.on_registration
+            @action_requests = inc_action.action_requests
+          end
+        end
+
+        def on_commit
+          # ignore Inc#on_commit
+          @model.clear_attribute_changes(@attribute)
+          @model.run_callbacks(:commit)
+        end
+
+        def on_rollback
+          # ignore Inc#on_rollback
+          @model.run_callbacks(:rollback)
+        end
+
+        def aborted?
+          # ignore Inc#abort?
+          false
+        end
+
+        def skipped?
+          # ignore Inc#skipped?
+          @by == 0 # rubocop:disable Style/NumericPredicate
+        end
+
+        def observable_by_user_result
+          @model
+        end
+
+        def action_requests # rubocop:disable Style/TrivialAccessors
+          @action_requests
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/transactions/mutation/save.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'builders/update_request_builder'
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class Save < Base
+        def initialize(model, **options)
+          super()
+
+          @model = model
+          @model_class = model.class
+          @options = options
+
+          @aborted = false
+          @was_new_record = model.new_record?
+          @valid = nil
+        end
+
+        def on_registration
+          if @options[:validate] != false && !(@valid = @model.valid?)
+            if @options[:raise_error]
+              raise Dynamoid::Errors::DocumentNotValid, @model
+            else
+              @aborted = true
+              return
+            end
+          end
+
+          @aborted = true
+          callback_name = @was_new_record ? :create : :update
+
+          @model.run_callbacks(:save) do
+            @model.run_callbacks(callback_name) do
+              @model.run_callbacks(:validate) do
+                validate_primary_key!
+
+                @aborted = false
+                true
+              end
+            end
+          end
+
+          if @aborted && @options[:raise_error]
+            raise Dynamoid::Errors::RecordNotSaved, @model
+          end
+
+          if @was_new_record && @model.hash_key.nil?
+            @model.hash_key = SecureRandom.uuid
+          end
+
+          if @model.class.attributes[:lock_version]
+            if @model.lock_version.nil? && @model.new_record?
+              @model.lock_version = 1
+            end
+
+            if @model.lock_version && !@model.changes[:lock_version]
+              @model.lock_version += 1
+            end
+          end
+        end
+
+        def on_commit
+          return if @aborted
+
+          @model.changes_applied
+
+          if @was_new_record
+            @model.new_record = false
+          end
+
+          @model.run_callbacks(:commit)
+        end
+
+        def on_rollback
+          @model.run_callbacks(:rollback)
+        end
+
+        def aborted?
+          @aborted
+        end
+
+        def skipped?
+          @model.persisted? && !@model.changed?
+        end
+
+        def observable_by_user_result
+          !@aborted
+        end
+
+        def action_requests
+          request = if @was_new_record
+                      action_request_to_create
+                    else
+                      action_request_to_update
+                    end
+
+          [request]
+        end
+
+        private
+
+        def validate_primary_key!
+          raise Dynamoid::Errors::MissingHashKey if !@was_new_record && @model.hash_key.nil?
+          raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @model.range_value.nil?
+        end
+
+        def action_request_to_create
+          touch_model_timestamps(skip_created_at: false)
+
+          attributes_dumped = Dynamoid::Dumping.dump_attributes(@model.attributes, @model_class.attributes)
+          attributes_dumped = sanitize_item(attributes_dumped)
+
+          # require primary key not to exist yet
+          expression_attribute_names = { '#_h' => @model_class.hash_key }
+          condition = 'attribute_not_exists(#_h)'
+
+          if @model_class.range_key?
+            expression_attribute_names['#_r'] = @model_class.range_key
+            condition += ' AND attribute_not_exists(#_r)'
+          end
+
+          {
+            put: {
+              item: attributes_dumped,
+              table_name: @model_class.table_name,
+              condition_expression: condition,
+              expression_attribute_names: expression_attribute_names
+            }
+          }
+        end
+
+        def action_request_to_update
+          touch_model_timestamps(skip_created_at: true)
+
+          # changed attributes to persist
+          changes = @model.attributes.slice(*@model.changed.map(&:to_sym))
+          changes_dumped = Dynamoid::Dumping.dump_attributes(changes, @model_class.attributes)
+
+          builder = Builders::UpdateRequestBuilder.new(@model_class)
+          builder.hash_key = dump_attribute(@model_class.hash_key, @model.hash_key)
+          builder.range_key = dump_attribute(@model_class.range_key, @model.range_value) if @model_class.range_key?
+
+          attributes_to_set = {}
+          attributes_to_remove = []
+
+          changes_dumped.each do |name, value|
+            if value || Dynamoid.config.store_attribute_with_nil_value
+              attributes_to_set[name] = value
+            else
+              attributes_to_remove << name
+            end
+          end
+
+          builder.set_attributes(attributes_to_set)
+          builder.remove_attributes(attributes_to_remove)
+
+          if @model_class.attributes[:lock_version]
+            lock_version = if @model.changes[:lock_version].nil?
+                             @model.lock_version
+                           else
+                             @model.changes[:lock_version][0]
+                           end
+
+            # skip concurrency control when lock_version is nil
+            if lock_version
+              builder.add_expression_attribute_name('#_lock_version', 'lock_version')
+              builder.add_expression_attribute_value(':lock_version_value', lock_version)
+              builder.condition_expression = '#_lock_version = :lock_version_value'
+            end
+          end
+
+          builder.request
+        end
+
+        def touch_model_timestamps(skip_created_at:)
+          return unless @model_class.timestamps_enabled?
+
+          timestamp = DateTime.now.in_time_zone(Time.zone)
+          @model.updated_at = timestamp unless @options[:touch] == false && !@was_new_record
+          @model.created_at ||= timestamp unless skip_created_at
+        end
+
+        def dump_attribute(name, value)
+          options = @model_class.attributes[name]
+          Dumping.dump_field(value, options)
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/transactions/mutation/touch.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'builders/update_request_builder'
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class Touch < Base
+        def initialize(model, *names, time: nil)
+          super()
+
+          @model = model
+          @names = names
+          @time = time
+        end
+
+        def on_registration
+          if @model.new_record?
+            raise Dynamoid::Errors::Error, 'cannot touch on a new or destroyed record object'
+          end
+
+          validate_primary_key!
+
+          @model.run_callbacks(:touch) do
+            @time_to_assign = @time || DateTime.now.in_time_zone(Time.zone)
+
+            @model.updated_at = @time_to_assign if @model.class.timestamps_enabled?
+            @names.each do |name|
+              @model.write_attribute(name, @time_to_assign)
+            end
+          end
+        end
+
+        def on_commit
+          attribute_names = @names.map(&:to_s)
+          attribute_names << 'updated_at' if @model.class.timestamps_enabled?
+          @model.clear_attribute_changes(attribute_names)
+          @model.run_callbacks(:commit)
+        end
+
+        def on_rollback
+          @model.run_callbacks(:rollback)
+        end
+
+        def aborted?
+          false
+        end
+
+        def skipped?
+          !@model.class.timestamps_enabled? && @names.empty?
+        end
+
+        def observable_by_user_result
+          @model
+        end
+
+        def action_requests
+          builder = Builders::UpdateRequestBuilder.new(@model.class)
+          builder.hash_key = dump(@model.class.hash_key, @model.hash_key)
+          builder.range_key = dump(@model.class.range_key, @model.range_value) if @model.class.range_key?
+
+          # require primary key to exist
+          builder.add_expression_attribute_name('#_h', @model.class.hash_key)
+          condition_expression = 'attribute_exists(#_h)'
+
+          if @model.class.range_key?
+            builder.add_expression_attribute_name('#_r', @model.class.range_key)
+            condition_expression += ' AND attribute_exists(#_r)'
+          end
+          builder.condition_expression = condition_expression
+
+          attributes_to_set = {}
+          attributes_to_set[:updated_at] = dump(:updated_at, @model[:updated_at]) if @model.class.timestamps_enabled?
+
+          @names.each do |name|
+            attributes_to_set[name] = dump(name, @model[name])
+          end
+
+          builder.set_attributes(attributes_to_set)
+          [builder.request]
+        end
+
+        private
+
+        def validate_primary_key!
+          raise Dynamoid::Errors::MissingHashKey if @model.hash_key.nil?
+          raise Dynamoid::Errors::MissingRangeKey if @model.class.range_key? && @model.range_value.nil?
+        end
+
+        def dump(name, value)
+          options = @model.class.attributes[name]
+          Dumping.dump_field(value, options)
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/transactions/mutation/update_attributes.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'dynamoid/persistence/update_validations'
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class UpdateAttributes < Base
+        def initialize(model, attributes, **options)
+          super()
+
+          @model = model
+          @model.assign_attributes(attributes)
+          @save_action = Save.new(model, **options)
+        end
+
+        def on_registration
+          @save_action.on_registration
+        end
+
+        def on_commit
+          @save_action.on_commit
+        end
+
+        def on_rollback
+          @save_action.on_rollback
+        end
+
+        def aborted?
+          @save_action.aborted?
+        end
+
+        def skipped?
+          @save_action.skipped?
+        end
+
+        def observable_by_user_result
+          @save_action.observable_by_user_result
+        end
+
+        def action_requests
+          @save_action.action_requests
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/transactions/mutation/update_fields.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'builders/update_request_builder'
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class UpdateFields < Base
+        class ItemUpdater
+          attr_reader :attributes_to_set, :attributes_to_add, :attributes_to_delete, :attributes_to_remove
+
+          def initialize(model_class)
+            @model_class = model_class
+
+            @attributes_to_set = {}
+            @attributes_to_add = {}
+            @attributes_to_delete = {}
+            @attributes_to_remove = []
+          end
+
+          def empty?
+            [@attributes_to_set, @attributes_to_add, @attributes_to_delete, @attributes_to_remove].all?(&:empty?)
+          end
+
+          def set(attributes)
+            validate_attribute_names!(attributes.keys)
+            if Dynamoid.config.store_attribute_with_nil_value
+              @attributes_to_set.merge!(attributes)
+            else
+              @attributes_to_set.merge!(attributes.reject { |_, v| v.nil? })
+              @attributes_to_remove += attributes.select { |_, v| v.nil? }.keys
+            end
+          end
+
+          # adds to array of fields for use in REMOVE update expression
+          def remove(*names)
+            validate_attribute_names!(names)
+            @attributes_to_remove += names
+          end
+
+          # increments a number or adds to a set, starts at 0 or [] if it doesn't yet exist
+          def add(attributes)
+            validate_attribute_names!(attributes.keys)
+            @attributes_to_add.merge!(attributes)
+          end
+
+          # deletes a value or values from a set
+          def delete(attributes)
+            validate_attribute_names!(attributes.keys)
+            @attributes_to_delete.merge!(attributes)
+          end
+
+          private
+
+          def validate_attribute_names!(names)
+            UpdateFields.validate_attribute_names!(@model_class, names)
+          end
+        end
+
+        def initialize(model_class, hash_key, range_key, attributes, &block)
+          super()
+
+          @model_class = model_class
+          @hash_key = hash_key
+          @range_key = range_key
+          @attributes = attributes || {}
+          @block = block
+        end
+
+        def on_registration
+          validate_primary_key!
+          validate_attribute_names!(@model_class, @attributes.keys)
+
+          if @block
+            @item_updater = ItemUpdater.new(@model_class)
+            @block.call(@item_updater)
+          end
+        end
+
+        def on_commit; end
+
+        def on_rollback; end
+
+        def aborted?
+          false
+        end
+
+        def skipped?
+          @attributes.empty? && (!@item_updater || @item_updater.empty?)
+        end
+
+        def observable_by_user_result
+          nil
+        end
+
+        def action_requests
+          builder = Builders::UpdateRequestBuilder.new(@model_class)
+
+          # primary key to look up an item to update
+          builder.hash_key = cast_and_dump(@model_class.hash_key, @hash_key)
+          builder.range_key = cast_and_dump(@model_class.range_key, @range_key) if @model_class.range_key?
+
+          # require primary key to exist
+          builder.add_expression_attribute_name('#_h', @model_class.hash_key)
+          condition_expression = 'attribute_exists(#_h)'
+
+          if @model_class.range_key?
+            builder.add_expression_attribute_name('#_r', @model_class.range_key)
+            condition_expression += ' AND attribute_exists(#_r)'
+          end
+          builder.condition_expression = condition_expression
+
+          # changed attributes to persist
+          changes = add_timestamps(@attributes, skip_created_at: true)
+          changes_dumped = Dynamoid::Dumping.dump_attributes(changes, @model_class.attributes)
+
+          if Dynamoid.config.store_attribute_with_nil_value
+            builder.set_attributes(changes_dumped)
+          else
+            nil_attributes = changes_dumped.select { |_, v| v.nil? }
+            non_nil_attributes = changes_dumped.reject { |_, v| v.nil? } # rubocop:disable Style/PartitionInsteadOfDoubleSelect
+
+            builder.remove_attributes(nil_attributes.keys)
+            builder.set_attributes(non_nil_attributes)
+          end
+
+          # given a block
+          if @item_updater
+            builder.set_attributes(@item_updater.attributes_to_set)
+            builder.remove_attributes(@item_updater.attributes_to_remove)
+
+            @item_updater.attributes_to_add.each do |name, value|
+              # The ADD section in UpdateExpressions requires values to be a
+              # set to update a set attribute.
+              # Allow specifying values as any Enumerable collection (e.g. Array).
+              # Allow a single value not wrapped into a Set
+              if @model_class.attributes[name][:type] == :set
+                value = value.is_a?(Enumerable) ? Set.new(value) : Set[value]
+              end
+
+              builder.add_value(name, value)
+            end
+
+            @item_updater.attributes_to_delete.each do |name, value|
+              # The DELETE section in UpdateExpressions requires values to be a
+              # set to update a set attribute.
+              # Allow specifying values as any Enumerable collection (e.g. Array).
+              # Allow a single value not wrapped into a Set
+              value = value.is_a?(Enumerable) ? Set.new(value) : Set[value]
+
+              builder.delete_value(name, value)
+            end
+          end
+
+          [builder.request]
+        end
+
+        private
+
+        def validate_primary_key!
+          raise Dynamoid::Errors::MissingHashKey if @hash_key.nil?
+          raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @range_key.nil?
+        end
+
+        def add_timestamps(attributes, skip_created_at: false)
+          return attributes unless @model_class.timestamps_enabled?
+
+          result = attributes.clone
+          timestamp = DateTime.now.in_time_zone(Time.zone)
+          result[:created_at] ||= timestamp unless skip_created_at
+          result[:updated_at] ||= timestamp
+          result
+        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
+end

data/lib/dynamoid/transactions/mutation/upsert.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'builders/update_request_builder'
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class Upsert < Base
+        def initialize(model_class, hash_key, range_key, attributes)
+          super()
+
+          @model_class = model_class
+          @hash_key = hash_key
+          @range_key = range_key
+          @attributes = attributes
+        end
+
+        def on_registration
+          validate_primary_key!
+          validate_attribute_names!(@model_class, @attributes.keys)
+        end
+
+        def on_commit; end
+
+        def on_rollback; end
+
+        def aborted?
+          false
+        end
+
+        def skipped?
+          attributes_to_assign = @attributes.except(@model_class.hash_key, @model_class.range_key)
+          attributes_to_assign.empty? && !@model_class.timestamps_enabled?
+        end
+
+        def observable_by_user_result
+          nil
+        end
+
+        def action_requests
+          # changed attributes to persist
+          changes = @attributes.dup
+          changes = add_timestamps(changes, skip_created_at: true)
+          changes_dumped = Dynamoid::Dumping.dump_attributes(changes, @model_class.attributes)
+
+          builder = Builders::UpdateRequestBuilder.new(@model_class)
+          builder.hash_key = cast_and_dump(@model_class.hash_key, @hash_key)
+          builder.range_key = cast_and_dump(@model_class.range_key, @range_key) if @model_class.range_key?
+
+          attributes_to_set = {}
+          attributes_to_remove = []
+
+          changes_dumped.each do |name, value|
+            if value || Dynamoid.config.store_attribute_with_nil_value
+              attributes_to_set[name] = value
+            else
+              attributes_to_remove << name
+            end
+          end
+
+          builder.set_attributes(attributes_to_set)
+          builder.remove_attributes(attributes_to_remove)
+
+          [builder.request]
+        end
+
+        private
+
+        def validate_primary_key!
+          raise Dynamoid::Errors::MissingHashKey if @hash_key.nil?
+          raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @range_key.nil?
+        end
+
+        def add_timestamps(attributes, skip_created_at: false)
+          return attributes unless @model_class.timestamps_enabled?
+
+          result = attributes.clone
+          timestamp = DateTime.now.in_time_zone(Time.zone)
+          result[:created_at] ||= timestamp unless skip_created_at
+          result[:updated_at] ||= timestamp
+          result
+        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
+end