dynamoid 3.13.0 → 3.14.0

data/lib/dynamoid/fields.rb

@@ -26,13 +26,15 @@ module Dynamoid
     module ClassMethods
       # Specify a field for a document.
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     field :last_name
-      #     field :age, :integer
-      #     field :last_sign_in, :datetime
-      #   end
+      #   field :last_name
+      #   field :age, :integer
+      #   field :last_sign_in, :datetime
+      # end
+      # ```
       #
       # Its type determines how it is coerced when read in and out of the
       # data store. You can specify +string+, +integer+, +number+, +set+, +array+,
@@ -101,35 +103,39 @@ module Dynamoid
       #
       # It works in the following way:
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     field :age, :integer
-      #   end
+      #   field :age, :integer
+      # end
       #
-      #   user = User.new
-      #   user.age # => nil
-      #   user.age? # => false
+      # user = User.new
+      # user.age # => nil
+      # user.age? # => false
       #
-      #   user.age = 20
-      #   user.age? # => true
+      # user.age = 20
+      # user.age? # => true
       #
-      #   user.age = '21'
-      #   user.age # => 21 - integer
-      #   user.age_before_type_cast # => '21' - string
+      # user.age = '21'
+      # user.age # => 21 - integer
+      # user.age_before_type_cast # => '21' - string
+      # ```
       #
       # There is also an option +alias+ which allows to use another name for a
       # field:
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     field :firstName, :string, alias: :first_name
-      #   end
+      #   field :firstName, :string, alias: :first_name
+      # end
       #
-      #   user = User.new(firstName: 'Michael')
-      #   user.firstName # Michael
-      #   user.first_name # Michael
+      # user = User.new(firstName: 'Michael')
+      # user.firstName # Michael
+      # user.first_name # Michael
+      # ```
       #
       # @param name [Symbol] name of the field
       # @param type [Symbol] type of the field (optional)
@@ -152,11 +158,13 @@ module Dynamoid
 
       # Declare a table range key.
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     range :last_name
-      #   end
+      #   range :last_name
+      # end
+      # ```
       #
       # By default a range key is a string. In order to use any other type it
       # should be specified as a second argument:
@@ -187,29 +195,35 @@ module Dynamoid
       #
       # The +table+ method can be used to override the defaults:
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     table name: :customers, key: :uuid
-      #   end
+      #   table name: :customers, key: :uuid
+      # end
+      # ```
       #
       # The hash key field is declared by default and a type is a string. If
       # another type is needed the field should be declared explicitly:
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     field :id, :integer
-      #   end
+      #   field :id, :integer
+      # end
+      # ```
       #
       # To declare a new attribute with not-default type as a table hash key a
       # :key_type option can be used:
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     table key: :user_id, key_type: :integer
-      #   end
+      #   table key: :user_id, key_type: :integer
+      # end
+      # ```
       #
       # @param options [Hash] options to override default table settings
       # @option options [Symbol] :name name of a table

data/lib/dynamoid/finders.rb

@@ -243,7 +243,7 @@ module Dynamoid
       #     field :email,  :string
       #     field :age,    :integer
       #     field :gender, :string
-      #     field :rank    :number
+      #     field :rank,   :number
       #   end
       #
       #   # NOTE: the first param and the second param are both hashes,

data/lib/dynamoid/indexes.rb

@@ -24,22 +24,26 @@ module Dynamoid
       # Defines a Global Secondary index on a table. Keys can be specified as
       # hash-only, or hash & range.
       #
-      #   class Post
-      #     include Dynamoid::Document
+      # ```
+      # class Post
+      #   include Dynamoid::Document
       #
-      #     field :category
+      #   field :category
       #
-      #     global_secondary_index hash_key: :category
-      #   end
+      #   global_secondary_index hash_key: :category
+      # end
+      # ```
       #
       # The full example with all the options being specified:
       #
-      #   global_secondary_index hash_key: :category,
-      #                          range_key: :created_at,
-      #                          name: 'posts_category_created_at_index',
-      #                          projected_attributes: :all,
-      #                          read_capacity: 100,
-      #                          write_capacity: 20
+      # ```
+      # global_secondary_index hash_key: :category,
+      #                        range_key: :created_at,
+      #                        name: 'posts_category_created_at_index',
+      #                        projected_attributes: :all,
+      #                        read_capacity: 100,
+      #                        write_capacity: 20
+      # ```
       #
       # Global secondary index should be declared after fields for mentioned
       # hash key and optional range key are declared (with method +field+)
@@ -88,21 +92,25 @@ module Dynamoid
       # Defines a local secondary index on a table. Will use the same primary
       # hash key as the table.
       #
-      #   class Comment
-      #     include Dynamoid::Document
+      # ```
+      # class Comment
+      #   include Dynamoid::Document
       #
-      #     table hash_key: :post_id
-      #     range :created_at, :datetime
-      #     field :author_id
+      #   table hash_key: :post_id
+      #   range :created_at, :datetime
+      #   field :author_id
       #
-      #     local_secondary_index range_key: :author_id
-      #   end
+      #   local_secondary_index range_key: :author_id
+      # end
+      # ```
       #
       # The full example with all the options being specified:
       #
-      #   local_secondary_index range_key: :created_at,
-      #                         name: 'posts_created_at_index',
-      #                         projected_attributes: :all
+      # ```
+      # local_secondary_index range_key: :created_at,
+      #                       name: 'posts_created_at_index',
+      #                       projected_attributes: :all
+      # ```
       #
       # Local secondary index should be declared after fields for mentioned
       # hash key and optional range key are declared (with method +field+) as

data/lib/dynamoid/persistence/inc.rb

@@ -6,7 +6,7 @@ module Dynamoid
   module Persistence
     # @private
     class Inc
-      def self.call(model_class, partition_key, sort_key = nil, counters)
+      def self.call(model_class, partition_key, sort_key = nil, counters) # rubocop:disable Style/OptionalArguments
         new(model_class, partition_key, sort_key, counters).call
       end
 
@@ -16,11 +16,14 @@ module Dynamoid
         @partition_key = partition_key
         @sort_key = sort_key
         @counters = counters
+        @touch = @counters.delete(:touch)
       end
       # rubocop:enable Style/OptionalArguments
 
       def call
-        touch = @counters.delete(:touch)
+        validate_primary_key!
+        Dynamoid::Persistence::UpdateValidations.validate_attributes_exist(@model_class, @counters)
+
         partition_key_dumped = cast_and_dump(@model_class.hash_key, @partition_key)
         options = update_item_options(partition_key_dumped)
 
@@ -31,10 +34,10 @@ module Dynamoid
             item_updater.add(name => value)
           end
 
-          if touch
+          if @touch
             value = DateTime.now.in_time_zone(Time.zone)
 
-            timestamp_attributes_to_touch(touch).each do |name|
+            timestamp_attributes_to_touch.each do |name|
               item_updater.set(name => value)
             end
           end
@@ -44,6 +47,11 @@ 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_options(partition_key_dumped)
         options = {}
 
@@ -63,12 +71,12 @@ module Dynamoid
         options
       end
 
-      def timestamp_attributes_to_touch(touch)
-        return [] unless touch
+      def timestamp_attributes_to_touch
+        return [] unless @touch
 
         names = []
         names << :updated_at if @model_class.timestamps_enabled?
-        names += Array.wrap(touch) if touch != true
+        names += Array.wrap(@touch) if @touch != true
         names
       end
 

data/lib/dynamoid/persistence/save.rb

@@ -30,12 +30,18 @@ module Dynamoid
 
         # Add an optimistic locking check if the lock_version column exists
         if @model.class.attributes[:lock_version]
-          @model.lock_version = (@model.lock_version || 0) + 1
+          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
 
         if @model.new_record?
           attributes_dumped = Dumping.dump_attributes(@model.attributes, @model.class.attributes)
-          Dynamoid.adapter.write(@model.class.table_name, attributes_dumped, conditions_for_write)
+          Dynamoid.adapter.write(@model.class.table_name, attributes_dumped, conditions_to_create_item)
         else
           attributes_to_persist = @model.attributes.slice(*@model.changed.map(&:to_sym))
           partition_key_dumped = dump(@model.class.hash_key, @model.hash_key)
@@ -68,7 +74,7 @@ module Dynamoid
       end
 
       # Should be called after incrementing `lock_version` attribute
-      def conditions_for_write
+      def conditions_to_create_item
         conditions = {}
 
         # Add an 'exists' check to prevent overwriting existing records with new ones
@@ -77,14 +83,6 @@ module Dynamoid
           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]
-          conditions[:if] ||= {}
-          conditions[:if][:lock_version] = @model.changes[:lock_version][0]
-        end
-
         conditions
       end
 
@@ -103,9 +101,18 @@ module Dynamoid
         # 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]
-          conditions[:if] ||= {}
-          conditions[:if][:lock_version] = @model.changes[:lock_version][0]
+        if @model.class.attributes[:lock_version]
+          lock_version = if @model.changes[:lock_version]
+                           @model.changes[:lock_version][0]
+                         else
+                           @model.lock_version
+                         end
+
+          # skip concurrency control when lock_version is nil
+          if lock_version
+            conditions[:if] ||= {}
+            conditions[:if][:lock_version] = lock_version
+          end
         end
 
         options[:conditions] = conditions

data/lib/dynamoid/persistence.rb

@@ -48,17 +48,19 @@ module Dynamoid
       #
       # For instance here
       #
-      #   class User
-      #     include Dynamoid::Document
+      # ```
+      # class User
+      #   include Dynamoid::Document
       #
-      #     table key: :uuid
-      #     range :last_name
+      #   table key: :uuid
+      #   range :last_name
       #
-      #     field :first_name
-      #     field :last_name
-      #   end
+      #   field :first_name
+      #   field :last_name
+      # end
       #
-      #   User.create_table
+      # User.create_table
+      # ```
       #
       # +create_table+ method call will create a table +dynamoid_users+ with
       # hash key +uuid+ and range key +name+, DynamoDB default billing mode and
@@ -186,9 +188,11 @@ module Dynamoid
       # Instantiates a model and pass it into an optional block to set other
       # attributes.
       #
-      #   User.create(first_name: 'Mark') do |u|
-      #     u.age = 21
-      #   end
+      # ```
+      # User.create(first_name: 'Mark') do |u|
+      #   u.age = 21
+      # end
+      # ```
       #
       # Validates model and runs callbacks.
       #
@@ -227,9 +231,11 @@ module Dynamoid
       # Instantiates a model and pass it into an optional block to set other
       # attributes.
       #
-      #   User.create!(first_name: 'Mark') do |u|
-      #     u.age = 21
-      #   end
+      # ```
+      # User.create!(first_name: 'Mark') do |u|
+      #   u.age = 21
+      # end
+      # ```
       #
       # Validates model and runs callbacks.
       #
@@ -448,6 +454,10 @@ module Dynamoid
       #   User.inc('1', age: 2, touch: :viewed_at)
       #   User.inc('1', age: 2, touch: [:viewed_at, :accessed_at])
       #
+      # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+      # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+      # required but has value +nil+ or is missing.
+      #
       # @param hash_key_value [Scalar value] hash key
       # @param range_key_value [Scalar value] range key (optional)
       # @param counters [Hash] value to increase by
@@ -850,23 +860,29 @@ module Dynamoid
     # Operation +add+ just adds a value for numeric attributes and join
     # collections if attribute is a set.
     #
-    #   user.update! do |t|
-    #     t.add(age: 1, followers_count: 5)
-    #     t.add(hobbies: ['skying', 'climbing'])
-    #   end
+    # ```
+    # user.update! do |t|
+    #   t.add(age: 1, followers_count: 5)
+    #   t.add(hobbies: ['skying', 'climbing'])
+    # end
+    # ```
     #
     # Operation +delete+ is applied to collection attribute types and
     # substructs one collection from another.
     #
-    #   user.update! do |t|
-    #     t.delete(hobbies: ['skying'])
-    #   end
+    # ```
+    # user.update! do |t|
+    #   t.delete(hobbies: ['skying'])
+    # end
+    # ```
     #
     # Operation +set+ just changes an attribute value:
     #
-    #   user.update! do |t|
-    #     t.set(age: 21)
-    #   end
+    # ```
+    # user.update! do |t|
+    #   t.set(age: 21)
+    # end
+    # ```
     #
     # All the operations work like +ADD+, +DELETE+ and +PUT+ actions supported
     # by +AttributeUpdates+
@@ -879,18 +895,22 @@ module Dynamoid
     #
     # Can update a model conditionaly:
     #
-    #   user.update!(if: { age: 20 }) do |t|
-    #     t.add(age: 1)
-    #   end
+    # ```
+    # user.update!(if: { age: 20 }) do |t|
+    #   t.add(age: 1)
+    # end
+    # ```
     #
     # To check if some attribute (or attributes) isn't stored in a DynamoDB
     # item (e.g. it wasn't set explicitly) there is another condition -
     # +unless_exists+:
     #
-    #   user = User.create(name: 'Tylor')
-    #   user.update!(unless_exists: [:age]) do |t|
-    #     t.set(age: 18)
-    #   end
+    # ```
+    # user = User.create(name: 'Tylor')
+    # user.update!(unless_exists: [:age]) do |t|
+    #   t.set(age: 18)
+    # end
+    # ```
     #
     # If a document doesn't meet conditions it raises
     # +Dynamoid::Errors::StaleObjectError+ exception.
@@ -957,36 +977,46 @@ module Dynamoid
     # Operation +add+ just adds a value for numeric attributes and join
     # collections if attribute is a set.
     #
-    #   user.update do |t|
-    #     t.add(age: 1, followers_count: 5)
-    #     t.add(hobbies: ['skying', 'climbing'])
-    #   end
+    # ```
+    # user.update do |t|
+    #   t.add(age: 1, followers_count: 5)
+    #   t.add(hobbies: ['skying', 'climbing'])
+    # end
+    # ```
     #
     # Operation +delete+ is applied to collection attribute types and
     # substructs one collection from another.
     #
-    #   user.update do |t|
-    #     t.delete(hobbies: ['skying'])
-    #   end
+    # ```
+    # user.update do |t|
+    #   t.delete(hobbies: ['skying'])
+    # end
+    # ```
     #
     # If it's applied to a scalar attribute then the item's attribute is
     # removed at all:
     #
-    #   user.update do |t|
-    #     t.delete(age: nil)
-    #   end
+    # ```
+    # user.update do |t|
+    #   t.delete(age: nil)
+    # end
+    # ```
     #
     # or even without useless value at all:
     #
-    #   user.update do |t|
-    #     t.delete(:age)
-    #   end
+    # ```
+    # user.update do |t|
+    #   t.delete(:age)
+    # end
+    # ```
     #
     # Operation +set+ just changes an attribute value:
     #
-    #   user.update do |t|
-    #     t.set(age: 21)
-    #   end
+    # ```
+    # user.update do |t|
+    #   t.set(age: 21)
+    # end
+    # ```
     #
     # All the operations works like +ADD+, +DELETE+ and +PUT+ actions supported
     # by +AttributeUpdates+
@@ -995,18 +1025,22 @@ module Dynamoid
     #
     # Can update a model conditionaly:
     #
-    #   user.update(if: { age: 20 }) do |t|
-    #     t.add(age: 1)
-    #   end
+    # ```
+    # user.update(if: { age: 20 }) do |t|
+    #   t.add(age: 1)
+    # end
+    # ```
     #
     # To check if some attribute (or attributes) isn't stored in a DynamoDB
     # item (e.g. it wasn't set explicitly) there is another condition -
     # +unless_exists+:
     #
-    #   user = User.create(name: 'Tylor')
-    #   user.update(unless_exists: [:age]) do |t|
-    #     t.set(age: 18)
-    #   end
+    # ```
+    # user = User.create(name: 'Tylor')
+    # user.update(unless_exists: [:age]) do |t|
+    #   t.set(age: 18)
+    # end
+    # ```
     #
     # If a document doesn't meet conditions it just returns +false+. Otherwise it returns +true+.
     #

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Transactions
+    class Mutation
+      # @private
+      class Base
+        # Callback called at "initialization" or "registration" an action
+        # before changes are persisted. It's a proper place to validate
+        # a model or run callbacks
+        def on_registration
+          raise 'Not implemented'
+        end
+
+        # Callback called after changes are persisted.
+        # It's a proper place to mark changes in a model as applied.
+        def on_commit
+          raise 'Not implemented'
+        end
+
+        # Callback called when a transaction is rolled back.
+        # It's a proper place to undo changes made in after_... callbacks.
+        def on_rollback
+          raise 'Not implemented'
+        end
+
+        # Whether some callback aborted or canceled an action
+        def aborted?
+          raise 'Not implemented'
+        end
+
+        # Whether there are changes to persist, e.g. updating a model with no
+        # attribute changed is skipped.
+        def skipped?
+          raise 'Not implemented'
+        end
+
+        # Value returned to a user as an action result
+        def observable_by_user_result
+          raise 'Not implemented'
+        end
+
+        # Coresponding part of a final request body
+        def action_requests
+          raise 'Not implemented'
+        end
+
+        def self.validate_attribute_names!(model_class, names)
+          names.each do |name|
+            unless model_class.attributes[name]
+              raise Dynamoid::Errors::UnknownAttribute.new(model_class, name)
+            end
+          end
+        end
+
+        private
+
+        def validate_attribute_names!(model_class, names)
+          self.class.validate_attribute_names!(model_class, names)
+        end
+
+        # copied from aws_sdk_v3
+        def sanitize_item(attributes)
+          config_value = Dynamoid.config.store_attribute_with_nil_value
+          store_attribute_with_nil_value = config_value.nil? ? false : !!config_value
+
+          attributes.reject do |_, v|
+            !store_attribute_with_nil_value && v.nil?
+          end.transform_values do |v|
+            v.is_a?(Hash) ? v.stringify_keys : v
+          end
+        end
+      end
+    end
+  end
+end