dynamoid 3.7.1 → 3.9.0

data/lib/dynamoid/document.rb

@@ -17,12 +17,6 @@ module Dynamoid
     end
 
     module ClassMethods
-      # @private
-      def table(options = {})
-        self.options = options
-        super if defined? super
-      end
-
       def attr_readonly(*read_only_attributes)
         self.read_only_attributes.concat read_only_attributes.map(&:to_s)
       end
@@ -77,10 +71,10 @@ module Dynamoid
 
       # Return the count of items for this class.
       #
-      # It returns aproximate value based on DynamoDB statistic. DynamoDB
-      # updates it periodicaly so the value can be no accurate.
+      # It returns approximate value based on DynamoDB statistic. DynamoDB
+      # updates it periodically so the value can be no accurate.
       #
-      # It's a reletivly cheap operation and doesn't read all the items in a
+      # It's a reletively cheap operation and doesn't read all the items in a
       # table. It makes just one HTTP request to DynamoDB.
       #
       # @return [Integer] items count in a table
@@ -166,6 +160,22 @@ module Dynamoid
         end
       end
 
+      attr_accessor :abstract_class
+
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def sti_name
+        name
+      end
+
+      def sti_class_for(type_name)
+        type_name.constantize
+      rescue NameError
+        raise Errors::SubclassNotFound, "STI subclass does not found. Subclass: '#{type_name}'"
+      end
+
       # @private
       def deep_subclasses
         subclasses + subclasses.map(&:deep_subclasses).flatten
@@ -173,7 +183,7 @@ module Dynamoid
 
       # @private
       def choose_right_class(attrs)
-        attrs[inheritance_field] ? attrs[inheritance_field].constantize : self
+        attrs[inheritance_field] ? sti_class_for(attrs[inheritance_field]) : self
       end
     end
 
@@ -212,7 +222,7 @@ module Dynamoid
         load(attrs_with_defaults.merge(attrs_virtual))
 
         if block
-          block.call(self)
+          yield(self)
         end
       end
     end
@@ -220,7 +230,7 @@ module Dynamoid
     # Check equality of two models.
     #
     # A model is equal to another model only if their primary keys (hash key
-    # and optionaly range key) are equal.
+    # and optionally range key) are equal.
     #
     # @return [true|false]
     # @since 0.2.0
@@ -284,6 +294,26 @@ module Dynamoid
       end
     end
 
+    def inspect
+      # attributes order is:
+      # - partition key
+      # - sort key
+      # - user defined attributes
+      # - timestamps - created_at/updated_at
+      names = [self.class.hash_key]
+      names << self.class.range_key if self.class.range_key
+      names += self.class.attributes.keys - names - %i[created_at updated_at]
+      names << :created_at if self.class.attributes.key?(:created_at)
+      names << :updated_at if self.class.attributes.key?(:updated_at)
+
+      inspection = names.map do |name|
+        value = read_attribute(name)
+        "#{name}: #{value.inspect}"
+      end.join(', ')
+
+      "#<#{self.class.name} #{inspection}>"
+    end
+
     private
 
     def dumped_range_value

data/lib/dynamoid/errors.rb

@@ -77,5 +77,7 @@ module Dynamoid
     class UnsupportedKeyType < Error; end
 
     class UnknownAttribute < Error; end
+
+    class SubclassNotFound < Error; end
   end
 end

data/lib/dynamoid/fields.rb

@@ -8,17 +8,6 @@ module Dynamoid
   module Fields
     extend ActiveSupport::Concern
 
-    # @private
-    # Types allowed in indexes:
-    PERMITTED_KEY_TYPES = %i[
-      number
-      integer
-      string
-      date
-      datetime
-      serialized
-    ].freeze
-
     # Initialize the attributes we know the class has, in addition to our magic attributes: id, created_at, and updated_at.
     included do
       class_attribute :attributes, instance_accessor: false
@@ -220,20 +209,26 @@ module Dynamoid
       #
       # @since 0.4.0
       def table(options)
+        self.options = options
+
         # a default 'id' column is created when Dynamoid::Document is included
         unless attributes.key? hash_key
           remove_field :id
           field(hash_key)
         end
 
+        # The created_at/updated_at fields are declared in the `included` callback first.
+        # At that moment the only known setting is `Dynamoid::Config.timestamps`.
+        # Now `options[:timestamps]` may override the global setting for a model.
+        # So we need to make decision again and declare the fields or rollback thier declaration.
+        #
+        # Do not replace with `#timestamps_enabled?`.
         if options[:timestamps] && !Dynamoid::Config.timestamps
-          # Timestamp fields weren't declared in `included` hook because they
-          # are disabled globaly
+          # The fields weren't declared in `included` callback because they are disabled globaly
           field :created_at, :datetime
           field :updated_at, :datetime
         elsif options[:timestamps] == false && Dynamoid::Config.timestamps
-          # Timestamp fields were declared in `included` hook but they are
-          # disabled for a table
+          # The fields were declared in `included` callback but they are disabled for a table
           remove_field :created_at
           remove_field :updated_at
         end
@@ -290,25 +285,28 @@ module Dynamoid
     #
     # @param name [Symbol] the name of the field
     # @param value [Object] the value to assign to that field
+    # @return [Dynamoid::Document] self
     #
     # @since 0.2.0
     def write_attribute(name, value)
       name = name.to_sym
+      old_value = read_attribute(name)
 
       unless attribute_is_present_on_model?(name)
-        raise Dynamoid::Errors::UnknownAttribute.new("Attribute #{name} is not part of the model")
+        raise Dynamoid::Errors::UnknownAttribute, "Attribute #{name} is not part of the model"
       end
 
       if association = @associations[name]
         association.reset
       end
 
-      attribute_will_change!(name) # Dirty API
-
       @attributes_before_type_cast[name] = value
 
       value_casted = TypeCasting.cast_field(value, self.class.attributes[name])
+      attribute_will_change!(name) if old_value != value_casted # Dirty API
+
       attributes[name] = value_casted
+      self
     end
     alias []= write_attribute
 
@@ -356,23 +354,6 @@ module Dynamoid
 
     private
 
-    # Automatically called during the created callback to set the created_at time.
-    #
-    # @since 0.2.0
-    def set_created_at
-      self.created_at ||= DateTime.now.in_time_zone(Time.zone) if self.class.timestamps_enabled?
-    end
-
-    # Automatically called during the save callback to set the updated_at time.
-    #
-    # @since 0.2.0
-    def set_updated_at
-      # @_touch_record=false means explicit disabling
-      if self.class.timestamps_enabled? && !updated_at_changed? && @_touch_record != false
-        self.updated_at = DateTime.now.in_time_zone(Time.zone)
-      end
-    end
-
     def set_expires_field
       options = self.class.options[:expires]
 
@@ -388,11 +369,12 @@ module Dynamoid
 
     def set_inheritance_field
       # actually it does only following logic:
-      # self.type ||= self.class.name if self.class.attributes[:type]
+      # self.type ||= self.class.sti_name if self.class.attributes[:type]
+      return if self.class.abstract_class?
 
       type = self.class.inheritance_field
       if self.class.attributes[type] && send(type).nil?
-        send("#{type}=", self.class.name)
+        send("#{type}=", self.class.sti_name)
       end
     end
 

data/lib/dynamoid/finders.rb

@@ -118,7 +118,7 @@ module Dynamoid
 
       # @private
       def _find_all(ids, options = {})
-        raise Errors::MissingRangeKey if range_key && ids.any? { |pk, sk| sk.nil? }
+        raise Errors::MissingRangeKey if range_key && ids.any? { |_pk, sk| sk.nil? }
 
         if range_key
           ids = ids.map do |pk, sk|
@@ -151,7 +151,9 @@ module Dynamoid
                 end
 
         if items.size == ids.size || !options[:raise_error]
-          items ? items.map { |i| from_database(i) } : []
+          models = items ? items.map { |i| from_database(i) } : []
+          models.each { |m| m.run_callbacks :find }
+          models
         else
           ids_list = range_key ? ids.map { |pk, sk| "(#{pk},#{sk})" } : ids.map(&:to_s)
           message = "Couldn't find all #{name.pluralize} with primary keys [#{ids_list.join(', ')}] "
@@ -173,7 +175,9 @@ module Dynamoid
         end
 
         if item = Dynamoid.adapter.read(table_name, id, options.slice(:range_key, :consistent_read))
-          from_database(item)
+          model = from_database(item)
+          model.run_callbacks :find
+          model
         elsif options[:raise_error]
           primary_key = range_key ? "(#{id},#{options[:range_key]})" : id
           message = "Couldn't find #{name} with primary key #{primary_key}"
@@ -294,7 +298,8 @@ module Dynamoid
       # @private
       # @since 0.2.0
       def method_missing(method, *args)
-        if method =~ /find/
+        # 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")
 
           finder = method.to_s.split('_by_').first

data/lib/dynamoid/indexes.rb

@@ -4,6 +4,15 @@ module Dynamoid
   module Indexes
     extend ActiveSupport::Concern
 
+    # @private
+    # @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey
+    # Types allowed in indexes
+    PERMITTED_KEY_DYNAMODB_TYPES = %i[
+      string
+      binary
+      number
+    ].freeze
+
     included do
       class_attribute :local_secondary_indexes, instance_accessor: false
       class_attribute :global_secondary_indexes, instance_accessor: false
@@ -20,17 +29,17 @@ module Dynamoid
       #
       #     field :category
       #
-      #     global_secondary_indexes hash_key: :category
+      #     global_secondary_index hash_key: :category
       #   end
       #
       # The full example with all the options being specified:
       #
-      #   global_secondary_indexes 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+)
@@ -86,14 +95,14 @@ module Dynamoid
       #     range :created_at, :datetime
       #     field :author_id
       #
-      #     local_secondary_indexes hash_key: :author_id
+      #     local_secondary_index range_key: :author_id
       #   end
       #
       # The full example with all the options being specified:
       #
-      #   local_secondary_indexes 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
@@ -160,10 +169,9 @@ module Dynamoid
       # @return [Dynamoid::Indexes::Index, nil] index object or nil if it isn't found
       def find_index_by_name(name)
         string_name = name.to_s
-        indexes.each_value.detect{ |i| i.name.to_s == string_name }
+        indexes.each_value.detect { |i| i.name.to_s == string_name }
       end
 
-
       # Returns true iff the provided hash[,range] key combo is a local
       # secondary index.
       #
@@ -290,39 +298,36 @@ module Dynamoid
         end
       end
 
+      def validate_hash_key
+        validate_index_key(:hash_key, @hash_key)
+      end
+
       def validate_range_key
-        if @range_key.present?
-          range_field_attributes = @dynamoid_class.attributes[@range_key]
-          if range_field_attributes.present?
-            range_key_type = range_field_attributes[:type]
-            if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(range_key_type)
-              @range_key_schema = {
-                @range_key => PrimaryKeyTypeMapping.dynamodb_type(range_key_type, range_field_attributes)
-              }
-            else
-              errors.add(:range_key, 'Index :range_key is not a valid key type')
-            end
-          else
-            errors.add(:range_key, "No such field #{@range_key} defined on table")
-          end
-        end
+        validate_index_key(:range_key, @range_key)
       end
 
-      def validate_hash_key
-        hash_field_attributes = @dynamoid_class.attributes[@hash_key]
-        if hash_field_attributes.present?
-          hash_field_type = hash_field_attributes[:type]
-          if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(hash_field_type)
-            @hash_key_schema = {
-              @hash_key => PrimaryKeyTypeMapping.dynamodb_type(hash_field_type, hash_field_attributes)
-            }
-          else
-            errors.add(:hash_key, 'Index :hash_key is not a valid key type')
-          end
+      def validate_index_key(key_param, key_val)
+        return if key_val.blank?
+
+        key_field_attributes = @dynamoid_class.attributes[key_val]
+        if key_field_attributes.blank?
+          errors.add(key_param, "No such field #{key_val} defined on table")
+          return
+        end
+
+        key_dynamodb_type = dynamodb_type(key_field_attributes[:type], key_field_attributes)
+        if PERMITTED_KEY_DYNAMODB_TYPES.include?(key_dynamodb_type)
+          send("#{key_param}_schema=", { key_val => key_dynamodb_type })
         else
-          errors.add(:hash_key, "No such field #{@hash_key} defined on table")
+          errors.add(key_param, "Index :#{key_param} is not a valid key type")
         end
       end
+
+      def dynamodb_type(field_type, options)
+        PrimaryKeyTypeMapping.dynamodb_type(field_type, options)
+      rescue Errors::UnsupportedKeyType
+        field_type
+      end
     end
   end
 end

data/lib/dynamoid/loadable.rb

@@ -8,12 +8,14 @@ module Dynamoid
       attrs.each do |key, value|
         send("#{key}=", value) if respond_to?("#{key}=")
       end
+
+      self
     end
 
     # 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.
     #
-    # @return [Dynamoid::Document] the document this method was called on
+    # @return [Dynamoid::Document] self
     #
     # @since 0.2.0
     def reload
@@ -24,7 +26,10 @@ module Dynamoid
       end
 
       self.attributes = self.class.find(hash_key, **options).attributes
+
       @associations.values.each(&:reset)
+      @new_record = false
+
       self
     end
   end

data/lib/dynamoid/log/formatter.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Dynamoid
   module Log
+    # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Log/Formatter.html
+    # https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Seahorse/Client/Response.html
+    # https://aws.amazon.com/ru/blogs/developer/logging-requests/
     module Formatter
-
-      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Log/Formatter.html
-      # https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Seahorse/Client/Response.html
-      # https://aws.amazon.com/ru/blogs/developer/logging-requests/
       class Debug
         def format(response)
           bold = "\x1b[1m"
@@ -21,6 +22,20 @@ module Dynamoid
           ].join("\n")
         end
       end
+
+      class Compact
+        def format(response)
+          bold = "\x1b[1m"
+          reset = "\x1b[0m"
+
+          [
+            response.context.operation.name,
+            bold,
+            response.context.http_request.body.string,
+            reset
+          ].join(' ')
+        end
+      end
     end
   end
 end

data/lib/dynamoid/persistence/import.rb

@@ -24,7 +24,10 @@ module Dynamoid
           import_with_backoff(models)
         end
 
-        models.each { |d| d.new_record = false }
+        models.each do |m|
+          m.new_record = false
+          m.clear_changes_information
+        end
         models
       end
 

data/lib/dynamoid/persistence/inc.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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
+      end
+
+      # rubocop:disable Style/OptionalArguments
+      def initialize(model_class, hash_key, range_key = nil, counters)
+        @model_class = model_class
+        @hash_key = hash_key
+        @range_key = range_key
+        @counters = counters
+      end
+      # rubocop:enable Style/OptionalArguments
+
+      def call
+        touch = @counters.delete(:touch)
+
+        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))
+          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))
+            end
+          end
+        end
+      end
+
+      private
+
+      def update_item_options
+        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
+          {}
+        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])
+      end
+
+      def timestamp_attributes_to_touch(touch)
+        return [] unless touch
+
+        names = []
+        names << :updated_at if @model_class.timestamps_enabled?
+        names += Array.wrap(touch) if touch != true
+        names
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence/save.rb

@@ -4,24 +4,44 @@ module Dynamoid
   module Persistence
     # @private
     class Save
-      def self.call(model)
-        new(model).call
+      def self.call(model, **options)
+        new(model, **options).call
       end
 
-      def initialize(model)
+      def initialize(model, touch: nil)
         @model = model
+        @touch = touch # touch=false means explicit disabling of updating the `updated_at` attribute
       end
 
       def call
         @model.hash_key = SecureRandom.uuid if @model.hash_key.blank?
 
+        return true unless @model.changed?
+
+        @model.created_at ||= DateTime.now.in_time_zone(Time.zone) if @model.class.timestamps_enabled?
+
+        if @model.class.timestamps_enabled? && !@model.updated_at_changed? && !(@touch == false && @model.persisted?)
+          @model.updated_at = DateTime.now.in_time_zone(Time.zone)
+        end
+
         # 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
         end
 
-        attributes_dumped = Dumping.dump_attributes(@model.attributes, @model.class.attributes)
-        Dynamoid.adapter.write(@model.class.table_name, attributes_dumped, conditions_for_write)
+        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)
+        else
+          attributes_to_persist = @model.attributes.slice(*@model.changed.map(&:to_sym))
+
+          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)
+            end
+          end
+        end
 
         @model.new_record = false
         true
@@ -59,6 +79,33 @@ module Dynamoid
 
         conditions
       end
+
+      def options_to_update_item
+        options = {}
+
+        if @model.class.range_key
+          value_dumped = Dumping.dump_field(@model.range_value, @model.class.attributes[@model.class.range_key])
+          options[:range_key] = value_dumped
+        end
+
+        conditions = {}
+        conditions[:if_exists] ||= {}
+        conditions[:if_exists][@model.class.hash_key] = @model.hash_key
+
+        # Add an optimistic locking check if the lock_version column exists
+        if @model.class.attributes[:lock_version]
+          # Uses the original lock_version value from Dirty API
+          # in case user changed 'lock_version' manually
+          if @model.changes[:lock_version][0]
+            conditions[:if] ||= {}
+            conditions[:if][:lock_version] = @model.changes[:lock_version][0]
+          end
+        end
+
+        options[:conditions] = conditions
+
+        options
+      end
     end
   end
 end

data/lib/dynamoid/persistence/update_fields.rb

@@ -19,7 +19,7 @@ module Dynamoid
       def call
         UpdateValidations.validate_attributes_exist(@model_class, @attributes)
 
-        if Dynamoid::Config.timestamps
+        if @model_class.timestamps_enabled?
           @attributes[:updated_at] ||= DateTime.now.in_time_zone(Time.zone)
         end
 

data/lib/dynamoid/persistence/update_validations.rb

@@ -9,7 +9,7 @@ module Dynamoid
 
         attributes.each do |attr_name, _|
           unless model_attributes.include?(attr_name)
-            raise Dynamoid::Errors::UnknownAttribute.new("Attribute #{attr_name} does not exist in #{model_class}")
+            raise Dynamoid::Errors::UnknownAttribute, "Attribute #{attr_name} does not exist in #{model_class}"
           end
         end
       end

data/lib/dynamoid/persistence/upsert.rb

@@ -19,7 +19,7 @@ module Dynamoid
       def call
         UpdateValidations.validate_attributes_exist(@model_class, @attributes)
 
-        if Dynamoid::Config.timestamps
+        if @model_class.timestamps_enabled?
           @attributes[:updated_at] ||= DateTime.now.in_time_zone(Time.zone)
         end