dynamoid 3.11.0 → 3.13.0

data/lib/dynamoid/fields.rb

@@ -134,6 +134,11 @@ module Dynamoid
       # @param name [Symbol] name of the field
       # @param type [Symbol] type of the field (optional)
       # @param options [Hash] any additional options for the field type (optional)
+      # @option options [Symbol] :of <description>
+      # @option options [Symbol] :store_as_string <description>
+      # @option options [Symbol] :store_as_native_boolean <description>
+      # @option options [Symbol] :default <description>
+      # @option options [Symbol] :alias <description>
       #
       # @since 0.2.0
       def field(name, type = :string, options = {})
@@ -197,10 +202,22 @@ module Dynamoid
       #     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
+      #
+      #     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
+      # @option options [Symbol] :arn table ARN; it allows referring tables in another AWS accounts; has higher priority than the +name+ option
       # @option options [Symbol] :key name of a hash key attribute
+      # @option options [Symbol] :key_type type of a hash key attribute
       # @option options [Symbol] :inheritance_field name of an attribute used for STI
+      # @option options [Array<Symbol>] :skip_generating_fields don't generate implicitly methods with given names, e.g. +:id+, +:created_at+, +:updated_at+
       # @option options [Symbol] :capacity_mode table billing mode - either +provisioned+ or +on_demand+
       # @option options [Integer] :write_capacity table write capacity units
       # @option options [Integer] :read_capacity table read capacity units
@@ -211,10 +228,17 @@ module Dynamoid
       def table(options)
         self.options = options
 
+        id_already_declared = true
+        timestamps_already_declared = Dynamoid::Config.timestamps
+
         # a default 'id' column is created when Dynamoid::Document is included
         unless attributes.key? hash_key
           remove_field :id
-          field(hash_key)
+          id_already_declared = false
+
+          key_type = options[:key_type] || :string
+          field(hash_key, key_type)
+          id_already_declared = hash_key == :id
         end
 
         # The created_at/updated_at fields are declared in the `included` callback first.
@@ -223,14 +247,30 @@ module Dynamoid
         # 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
+        if options[:timestamps] && !timestamps_already_declared
           # 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
+
+          timestamps_already_declared = true
+        elsif options[:timestamps] == false && timestamps_already_declared
           # The fields were declared in `included` callback but they are disabled for a table
           remove_field :created_at
           remove_field :updated_at
+
+          timestamps_already_declared = false
+        end
+
+        # handle :skip_generating_fields option
+        skip_generating_fields = options[:skip_generating_fields] || []
+        if id_already_declared && skip_generating_fields.include?(:id)
+          remove_field :id
+        end
+        if timestamps_already_declared && skip_generating_fields.include?(:created_at)
+          remove_field :created_at
+        end
+        if timestamps_already_declared && skip_generating_fields.include?(:updated_at)
+          remove_field :updated_at
         end
       end
 
@@ -291,7 +331,7 @@ module Dynamoid
       old_value = read_attribute(name)
 
       unless attribute_is_present_on_model?(name)
-        raise Dynamoid::Errors::UnknownAttribute, "Attribute #{name} is not part of the model"
+        raise Dynamoid::Errors::UnknownAttribute.new(self.class, name)
       end
 
       if association = @associations[name]

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+
@@ -107,24 +107,40 @@ module Dynamoid
 
       # @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
 
         read_options = options.slice(:consistent_read)
+        table = Dynamoid.adapter.describe_table(table_name)
 
         items = if Dynamoid.config.backoff
                   items = []
                   backoff = nil
                   Dynamoid.adapter.read(table_name, ids, read_options) do |hash, has_unprocessed_items|
-                    items += hash[table_name]
+                    # Cannot use #table_name because it may contain a table ARN, but response contains always a table name
+                    items += hash[table.name]
 
                     if has_unprocessed_items
                       backoff ||= Dynamoid.config.build_backoff
@@ -136,7 +152,9 @@ module Dynamoid
                   items
                 else
                   items = Dynamoid.adapter.read(table_name, ids, read_options)
-                  items ? items[table_name] : []
+
+                  # Cannot use #table_name because it may contain a table ARN, but response contains always a table name
+                  items ? items[table.name] : []
                 end
 
         if items.size == ids.size || !options[:raise_error]
@@ -144,7 +162,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 +171,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
@@ -308,6 +325,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/persistence/inc.rb

@@ -6,23 +6,25 @@ 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, @hash_key, update_item_options) do |t|
+        Dynamoid.adapter.update_item(@model_class.table_name, partition_key_dumped, options) do |t|
           item_updater = ItemUpdaterWithCastingAndDumping.new(@model_class, t)
 
           @counters.each do |name, value|
@@ -37,19 +39,28 @@ module Dynamoid
             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
+
+        options
       end
 
       def timestamp_attributes_to_touch(touch)
@@ -60,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/save.rb

@@ -12,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?
@@ -36,8 +38,10 @@ 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, @model.hash_key, options_to_update_item) do |t|
+          Dynamoid.adapter.update_item(@model.class.table_name, partition_key_dumped, options) do |t|
             item_updater = ItemUpdaterWithDumping.new(@model.class, t)
 
             attributes_to_persist.each do |name, value|
@@ -58,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
@@ -81,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
@@ -105,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

@@ -16,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?
@@ -32,8 +35,13 @@ 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|
@@ -50,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

@@ -19,6 +19,7 @@ module Dynamoid
       end
 
       def call
+        validate_primary_key!
         UpdateValidations.validate_attributes_exist(@model_class, @attributes)
 
         if @model_class.timestamps_enabled?
@@ -32,8 +33,15 @@ 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|
+        partition_key_dumped = cast_and_dump(@model_class.hash_key, @partition_key)
+
+        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|
@@ -46,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
@@ -58,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