dynamoid 3.11.0 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e13af88750cfc2b8421710068215b18cf596f86b0c5caa207574535af04369cc
-  data.tar.gz: b0cc179fb6c547fd766c788300bfe8fc38a9e10117895c0b39b665fcc609e448
+  metadata.gz: b115b0eb8a9244d3482f3b748edf42272f6d9ffa94db20c5c07c7d08a6a3cf6a
+  data.tar.gz: 60821b56861e74149f3751f0c58bbc58e6805a9b4db0a4b863527aad99748099
 SHA512:
-  metadata.gz: 3b363e83838f36600b1af31c59406ac4fccad981e24af8762d5ae73fd1b648a2d03754483be89ed648f7ca982dc1640901af242c0b626ef9fb34b3002438edb4
-  data.tar.gz: a1bc08e5ab754f0a2ee383d2ac335396e7e058ad3b91df2d7c532d346da79daa0d239053ab856a8dfd0a2bdfb213f70a654cecdd3b42901c0261e61bcaca9ad5
+  metadata.gz: 1eef7ad0569e01d06b8f52a273acff4621a23419bc7f83830dfb37a44149149ec41b010cfa96c4e81d51043b4c7154c7996c72d7e50b599b4ea969ff6bb7575f
+  data.tar.gz: ee7561403e8f0bfd2c0e29e2212c0cec903e264c83adc9d238d565054bc98f111d85b3e70e64e838d6c35a434d8b7ef3025eba347ccfee53d249a3834ce53dc0

data/CHANGELOG.md

@@ -11,21 +11,57 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
-## 3.11.0
+## 3.13.0
 
+### Fixed
+* [#944](https://github.com/Dynamoid/dynamoid/pull/944) Fix `#delete` and `#destroy` methods and set `#destroyed?` properly when operations fail
+* [#987](https://github.com/Dynamoid/dynamoid/pull/987) Fix checking that a primary key is given in transactional methods `#save` and `#destroy`
+### Added
+* [#941](https://github.com/Dynamoid/dynamoid/pull/941) Support table ARN and add option `:arn` for the `table` method to specify a table belonged to specific AWS account
+* [#943](https://github.com/Dynamoid/dynamoid/pull/943) Implement `delete` class method
+* [#945](https://github.com/Dynamoid/dynamoid/pull/945) Implement `#update_attribute!` method
+* [#947](https://github.com/Dynamoid/dynamoid/pull/947) Allow skipping default model fields generation and add option `:skip_generating_fields` for the `table` method to specify field names
+* [#988](https://github.com/Dynamoid/dynamoid/pull/988) Add Ruby 4.0 and Rails 8.1 in CI
+### Changed
+### Removed
+
+## 3.12.0 / 2025-08-23
+
+### Fixed
+* [#849](https://github.com/Dynamoid/dynamoid/pull/849) Fixed saving a field of custom type when it implements both `.dynamoid_dump()` and `#dynamoid_dump` method and use the former one.
+A proper behaviour is to use adapter's .dynamoid_dump method instead of a value's #dynamoid_dump method.
+* [#851](https://github.com/Dynamoid/dynamoid/pull/851) Fixed Dirty API and don't require custom types to implement `#==` method. Add field option `:comparable`.
+* [#913](https://github.com/Dynamoid/dynamoid/pull/913) Fixed saving partition keys of Dynamoid-specific types (e.g. `date` or `datetime`) and always convert them into a proper DynamoDB type
+* [#917](https://github.com/Dynamoid/dynamoid/pull/917) Fixed transactional write operations when primary key is of non-native DynamoDB type
+* [#927](https://github.com/Dynamoid/dynamoid/pull/927) Multiple fixes in transactional and non-transactional write methods and finders:
+  * Changed non-transactional method `#find` and raise `MissingHashKey` when a given partition key is `nil`
+  * Fixed non-transactional method `#save!` and raise `RecordNotSaved` when a callback throws `:abort` and terminates the process
+  * Check whether partition and sort key are specified in the non-transactional persistence methods and raise a proper exception (`MissingHashKey` or `MissingRangeKey`)
+  * Fixed methods `#inc`, `#increment!` and `#decrement!`, `#update` and `#update!` to not create a new item when an item with specified primary key is already deleted
+  * Fixed method `#update_attribute` to not raise `StaleObjectError` when an item with specified primary key is already deleted
+  * Fixed method `#where` with condition on a `:serialized` field to not raise an exception
+### Added
+* [#910](https://github.com/Dynamoid/dynamoid/pull/910) Added `key_type` option to the `table` method to change type of a partition key field (@ogidow)
+* [#916](https://github.com/Dynamoid/dynamoid/pull/916) Added new `error_on_scan` config option to raises an error and prevent table scans (DynamoDB's `Scan` operation) (@aaronalberg)
+* [#926](https://github.com/Dynamoid/dynamoid/pull/926) Implemented read transactions (using DynamoDB's `TransactGetItems` operation)
+### Changed
+* [#846](https://github.com/Dynamoid/dynamoid/pull/846) Changed transactional `update_fields()` method to accept a block and support low-level operations `set`, `add`, `delete`, `remove` (similar to the non-transactional `#update()` method) (@ckhsponge)
+### Removed
+
+## 3.11.0 / 2025-01-12
 ### Fixed
 * [#829](https://github.com/Dynamoid/dynamoid/pull/829) Fixed saving of in-place field changes
 * [#812](https://github.com/Dynamoid/dynamoid/pull/812) Restored sanitizing of attribute names in `#where` conditions
 * [#721](https://github.com/Dynamoid/dynamoid/pull/721) Fixed code examples in README.md (@ndjndj)
 ### Added
-* [#688](https://github.com/Dynamoid/dynamoid/pull/688) Transactional modifying was added utilizing `TransactWriteItems` operation (@ckhsponge)
+* [#688](https://github.com/Dynamoid/dynamoid/pull/688) Implemented write transactions (using DynamoDB's `TransactWriteItems` operation) (@ckhsponge)
 * [#794](https://github.com/Dynamoid/dynamoid/pull/794) Added new config option `store_empty_string_as_nil`
 * [#828](https://github.com/Dynamoid/dynamoid/pull/828) Added Ruby 3.4, Rails 8.0 and Rails 7.2 in CI
 ### Changed
 * [#832](https://github.com/Dynamoid/dynamoid/pull/832) Support String condition expressions with `#where`
 * [#822](https://github.com/Dynamoid/dynamoid/pull/822) Support binary type natively. Also added new config option `store_binary_as_native` (@dalibor)
 
-## 3.10.0
+## 3.10.0 / 2024-02-10
 ### Fixed
 * [#681](https://github.com/Dynamoid/dynamoid/pull/681) Fixed saving persisted model and deleting attributes with `nil` value if `config.store_attribute_with_nil_value` is `false`
 * [#716](https://github.com/Dynamoid/dynamoid/pull/716), [#691](https://github.com/Dynamoid/dynamoid/pull/691), [#687](https://github.com/Dynamoid/dynamoid/pull/687), [#660](https://github.com/Dynamoid/dynamoid/pull/660) Numerous fixes in README.md and RDoc documentation (@ndjndj, @kiharito, @dunkOnIT)

data/README.md

@@ -24,8 +24,8 @@ DynamoDB is not like other document-based databases you might know, and
 is very different indeed from relational databases. It sacrifices
 anything beyond the simplest relational queries and transactional
 support to provide a fast, cost-efficient, and highly durable storage
-solution. If your database requires complicated relational queries and
-transaction support, then this modest Gem cannot provide them for you,
+solution. If your database requires complicated relational queries
+then this modest Gem cannot provide them for you
 and neither can DynamoDB. In those cases you would do better to look
 elsewhere for your database needs.
 
@@ -102,8 +102,8 @@ credentials = Aws::AssumeRoleCredentials.new(
 )
 
 Dynamoid.configure do |config|
-  config.region = 'us-west-2',
-                  config.credentials = credentials
+  config.region = 'us-west-2'
+  config.credentials = credentials
 end
 ```
 
@@ -132,8 +132,8 @@ end
 Dynamoid supports Ruby >= 2.3 and Rails >= 4.2.
 
 Its compatibility is tested against following Ruby versions: 2.3, 2.4,
-2.5, 2.6, 2.7, 3.0, 3.1, 3.2 and 3.3, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
-5.2, 6.0, 6.1, 7.0 and 7.1.
+2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4, and 4.0, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
+5.2, 6.0, 6.1, 7.0, 7.1, 7.2, 8.0, and 8.1.
 
 ## Setup
 
@@ -471,6 +471,27 @@ method, which would return either `:string` or `:number`.
 DynamoDB may support some other attribute types that are not yet
 supported by Dynamoid.
 
+If a custom type implements `#==` method you can specify `comparable:
+true` option in a field declaration to specify that an object is safely
+comparable for the purpose of detecting changes. By default old and new
+objects will be compared by their serialized representation.
+
+```ruby
+class Money
+  # ...
+
+  def ==(other)
+    # comparison logic
+  end
+end
+
+class User
+  # ...
+
+  field :balance, Money, comparable: true
+end
+```
+
 ### Sort key
 
 Along with partition key table may have a sort key. In order to declare
@@ -620,6 +641,7 @@ with `inheritance_field` table option:
 ```ruby
 class Car
   include Dynamoid::Document
+
   table inheritance_field: :my_new_type
 
   field :my_new_type
@@ -914,6 +936,7 @@ It could be done with `project` method:
 ```ruby
 class User
   include Dynamoid::Document
+
   field :name
 end
 
@@ -1091,6 +1114,14 @@ on the base table*
 > Please note that this API is experimental and can be changed in
 > future releases.
 
+DynamoDB supports modifying and reading operations but there are some
+limitations:
+- read and write operation cannot be combined in the same transaction
+- operations are executed in batch, so operations should be given before
+  actual execution and cannot be changed on the fly
+
+#### Modifying transactions
+
 Multiple modifying actions can be grouped together and submitted as an
 all-or-nothing operation. Atomic modifying operations are supported in
 Dynamoid using transactions. If any action in the transaction fails they
@@ -1100,7 +1131,7 @@ The following actions are supported:
 
 * `#create`/`#create!` - add a new model if it does not already exist
 * `#save`/`#save!` - create or update model
-* `#update_attributes`/`#update_attributes!` - modifies one or more attributes from an existig
+* `#update_attributes`/`#update_attributes!` - modifies one or more attributes from an existing
 model
 * `#delete` - remove an model without callbacks nor validations
 * `#destroy`/`#destroy!` - remove an model
@@ -1110,8 +1141,7 @@ model
 These methods are supposed to behave exactly like their
 non-transactional counterparts.
 
-
-#### Create models
+##### Create models
 
 Models can be created inside of a transaction. The partition and sort
 keys, if applicable, are used to determine uniqueness. Creating will
@@ -1135,7 +1165,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Save models
+##### Save models
 
 Models can be saved in a transaction. New records are created otherwise
 the model is updated. Save, create, update, validate and destroy
@@ -1154,7 +1184,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Update models
+##### Update models
 
 A model can be updated by providing a model or primary key, and the fields to update.
 
@@ -1166,10 +1196,23 @@ Dynamoid::TransactionWrite.execute do |txn|
   # sets the name and title for a user
   # The user is found by id (that equals 1)
   txn.update_fields(User, '1', name: 'bob', title: 'mister')
+
+  # sets the name, increments a count and deletes a field
+  txn.update_fields(User, 1) do |t|
+    t.set(name: 'bob')
+    t.add(article_count: 1)
+    t.delete(:title)
+  end
+
+  # adds to a set of integers and deletes from a set of strings
+  txn.update_fields(User, 2) do |t|
+    t.add(friend_ids: [1, 2])
+    t.delete(child_names: ['bebe'])
+  end
 end
 ```
 
-#### Destroy or delete models
+##### Destroy or delete models
 
 Models can be used or the model class and key can be specified.
 `#destroy` uses callbacks and validations. Use `#delete` to skip
@@ -1188,7 +1231,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Validation failures that don't raise
+##### Validation failures that don't raise
 
 All of the transaction methods can be called without the `!` which
 results in `false` instead of a raised exception when validation fails.
@@ -1208,7 +1251,7 @@ Dynamoid::TransactionWrite.execute do |txn|
 end
 ```
 
-#### Incrementally building a transaction
+##### Incrementally building a transaction
 
 Transactions can also be built without a block.
 
@@ -1222,6 +1265,41 @@ transaction.upsert(Address, 'A#1', street: '123')
 transaction.commit # changes are persisted in this moment
 ```
 
+#### Reading transactions
+
+Multiple reading actions can be grouped together and submitted as an
+all-or-nothing operation. Atomic  operations are supported in Dynamoid
+using transactions. If any action in the transaction fails they all
+fail.
+
+The following actions are supported:
+
+* `#find` - load a single model or multiple models by its primary key
+
+These methods are supposed to behave exactly like their
+non-transactional counterparts.
+
+##### Find a model
+
+The `#find` action can load single model or multiple ones. Different
+model classes can be mixed in the same transactions. Result is returned
+as a plain list of all the found models. The order is preserved.
+
+```ruby
+user, address = Dynamoid::TransactionRead.execute do |t|
+  t.find(User, user_id)
+  t.find(Address, address_id)
+end
+```
+
+Multiple primary keys can be specified at once:
+
+```ruby
+users = Dynamoid::TransactionRead.execute do |t|
+  t.find(User, [id1, id2, id3])
+end
+```
+
 ### PartiQL
 
 To run PartiQL statements `Dynamoid.adapter.execute` method should be
@@ -1269,6 +1347,7 @@ Listed below are all configuration options.
 * `write_capacity` - is used at table or indices creation. Default is 20
   (units)
 * `warn_on_scan` - log warnings when scan table. Default is `true`
+* `error_on_scan` - raises an error when scan table. Default is `false`
 * `endpoint` - if provided, it communicates with the DynamoDB listening
   at the endpoint. This is useful for testing with
   [DynamoDB Local](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html)
@@ -1501,6 +1580,7 @@ order to troubleshoot and debug issues just set it:
 ```ruby
 class User
   include Dynamoid::Document
+
   field name
 end
 

data/SECURITY.md

@@ -4,14 +4,14 @@
 
 | Version | Supported |
 |---------|-----------|
-| 3.7.x   | ✅         |
-| <= 3.6  | ❌         |
+| 3.12.x   | ✅         |
+| < 3.12  | ❌         |
 | 2.x     | ❌         |
 | 1.x     | ❌         |
 | 0.x     | ❌         |
 
-## Reporting a Vulnerability
+## Security contact information
 
-Peter Boling is responsible for the security maintenance of this gem. Please find a way
-to [contact him directly](https://railsbling.com/contact) to report the issue. Include as much relevant information as
-possible.
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/batch_get_item.rb

@@ -63,9 +63,11 @@ module Dynamoid
                    ids.map { |hk, rk| { table.hash_key => hk, table.range_key => rk } }
                  end
 
+          table_name = table.local? ? table.name : table.arn
+
           {
             request_items: {
-              table.name => {
+              table_name => {
                 keys: keys,
                 consistent_read: options[:consistent_read]
               }

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/item_updater.rb

@@ -58,7 +58,7 @@ module Dynamoid
             # delete explicitly attributes if assigned nil value and configured
             # to not store nil values
             values_to_update = values_sanitized.reject { |_, v| v.nil? }
-            values_to_delete = values_sanitized.select { |_, v| v.nil? }
+            values_to_delete = values_sanitized.select { |_, v| v.nil? } # rubocop:disable Style/PartitionInsteadOfDoubleSelect
 
             @updates.merge!(values_to_update)
             @deletions.merge!(values_to_delete)

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/query.rb

@@ -64,6 +64,9 @@ module Dynamoid
           name_placeholders = {}
           value_placeholders = {}
 
+          # use table arn if it's configured for a model
+          table_name = table.local? ? table.name : table.arn
+
           # Deal with various limits and batching
           batch_size = options[:batch_size]
           limit = [record_limit, scan_limit, batch_size].compact.min
@@ -93,7 +96,7 @@ module Dynamoid
             :exclusive_start_key
           ).compact
 
-          request[:table_name]                  = table.name
+          request[:table_name]                  = table_name
           request[:limit]                       = limit                     if limit
           request[:key_condition_expression]    = key_condition_expression  if key_condition_expression.present?
           request[:filter_expression]           = filter_expression         if filter_expression.present?

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/scan.rb

@@ -57,6 +57,9 @@ module Dynamoid
           name_placeholders = {}
           value_placeholders = {}
 
+          # use table arn if it's configured for a model
+          table_name = table.local? ? table.name : table.arn
+
           # Deal with various limits and batching
           batch_size = options[:batch_size]
           limit = [record_limit, scan_limit, batch_size].compact.min
@@ -79,7 +82,7 @@ module Dynamoid
             :index_name
           ).compact
 
-          request[:table_name]                  = table.name
+          request[:table_name]                  = table_name
           request[:limit]                       = limit                 if limit
           request[:filter_expression]           = filter_expression     if filter_expression.present?
           request[:expression_attribute_values] = value_placeholders    if value_placeholders.present?

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/table.rb

@@ -14,6 +14,7 @@ module Dynamoid
         #
         def initialize(schema)
           @schema = schema[:table]
+          @local = false
         end
 
         def range_key
@@ -47,6 +48,18 @@ module Dynamoid
         def name
           schema[:table_name]
         end
+
+        def arn
+          schema[:table_arn]
+        end
+
+        def local!
+          @local = true
+        end
+
+        def local?
+          @local
+        end
       end
     end
   end

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -294,6 +294,14 @@ module Dynamoid
         Transact.new(client).transact_write_items(items)
       end
 
+      def transact_read_items(items)
+        request = {
+          transact_items: items,
+          return_consumed_capacity: 'TOTAL',
+        }
+        client.transact_get_items(request)
+      end
+
       # Create a table on DynamoDB. This usually takes a long time to complete.
       #
       # @param [String] table_name the name of the table to create
@@ -313,6 +321,22 @@ module Dynamoid
         false
       end
 
+      #
+      # New, semi-arbitrary API to get data on the table
+      #
+      def describe_table(table_name, reload: false)
+        (!reload && table_cache[table_name]) || begin
+          response = client.describe_table(table_name: table_name)
+          table = Table.new(response.data)
+
+          if table.name == table_name.to_s
+            table.local!
+          end
+
+          table_cache[table_name] = table
+        end
+      end
+
       def update_time_to_live(table_name, attribute)
         request = {
           table_name: table_name,
@@ -646,15 +670,6 @@ module Dynamoid
         expected
       end
 
-      #
-      # New, semi-arbitrary API to get data on the table
-      #
-      def describe_table(table_name, reload: false)
-        (!reload && table_cache[table_name]) || begin
-          table_cache[table_name] = Table.new(client.describe_table(table_name: table_name).data)
-        end
-      end
-
       #
       # Converts a hash returned by get_item, scan, etc. into a key-value hash
       #

data/lib/dynamoid/config.rb

@@ -36,6 +36,7 @@ module Dynamoid
     option :read_capacity, default: 100
     option :write_capacity, default: 20
     option :warn_on_scan, default: true
+    option :error_on_scan, default: false
     option :endpoint, default: nil
     option :identity_map, default: false
     option :timestamps, default: true

data/lib/dynamoid/criteria/chain.rb

@@ -563,7 +563,7 @@ module Dynamoid
         if @key_fields_detector.key_present?
           raw_pages_via_query
         else
-          issue_scan_warning if Dynamoid::Config.warn_on_scan && !@where_conditions.empty?
+          validate_scan_conditions
           raw_pages_via_scan
         end
       end
@@ -598,6 +598,12 @@ module Dynamoid
         end
       end
 
+      def validate_scan_conditions
+        raise Dynamoid::Errors::ScanProhibited if Dynamoid::Config.error_on_scan && !@where_conditions.empty?
+
+        issue_scan_warning if Dynamoid::Config.warn_on_scan && !@where_conditions.empty?
+      end
+
       def issue_scan_warning
         Dynamoid.logger.warn 'Queries without an index are forced to use scan and are generally much slower than indexed queries!'
         Dynamoid.logger.warn "You can index this query by adding index declaration to #{source.to_s.underscore}.rb:"
@@ -697,11 +703,13 @@ module Dynamoid
       # e.g. for NULL operator value should be boolean
       # and isn't related to an attribute own type
       def type_cast_condition_parameter(key, value)
-        return value if %i[array set].include?(source.attributes[key.to_sym][:type])
+        field_type = source.attributes[key.to_sym][:type]
+
+        return value if %i[array set].include?(field_type)
 
         if [true, false].include?(value) # Support argument for null/not_null operators
           value
-        elsif !value.respond_to?(:to_ary)
+        elsif !value.respond_to?(:to_ary) || field_type == :serialized
           options = source.attributes[key.to_sym]
           value_casted = TypeCasting.cast_field(value, options)
           Dumping.dump_field(value_casted, options)

data/lib/dynamoid/dirty.rb

@@ -301,7 +301,19 @@ module Dynamoid
       return false if value_from_database.nil?
 
       value = read_attribute(name)
-      value != value_from_database
+      type_options = self.class.attributes[name.to_sym]
+
+      unless type_options[:type].is_a?(Class) && !type_options[:comparable]
+        # common case
+        value != value_from_database
+      else
+        # objects of a custom type that does not implement its own `#==` method
+        # (that's declared by `comparable: false` or just not specifying the
+        # option `comparable`) are compared by comparing their dumps
+        dump = Dumping.dump_field(value, type_options)
+        dump_from_database = Dumping.dump_field(value_from_database, type_options)
+        dump != dump_from_database
+      end
     end
 
     module DeepDupper
@@ -318,26 +330,25 @@ module Dynamoid
 
         case value
         when NilClass, TrueClass, FalseClass, Numeric, Symbol, IO
-          # till Ruby 2.4 these immutable objects could not be duplicated
-          # IO objects cannot be duplicated - is used for binary fields
+          # Till Ruby 2.4 these immutable objects could not be duplicated.
+          # IO objects (used for the binary type) cannot be duplicated as well.
           value
-        when String
-          value.dup
         when Array
-          if of.is_a? Class # custom type
+          if of.is_a? Class
+            # custom type
             value.map { |e| dup_attribute(e, type: of) }
           else
             value.deep_dup
           end
         when Set
           Set.new(value.map { |e| dup_attribute(e, type: of) })
-        when Hash
-          value.deep_dup
         else
-          if type.is_a? Class # custom type
-            Marshal.load(Marshal.dump(value)) # dup instance variables
+          if type.is_a? Class
+            # custom type
+            dump = Dumping.dump_field(value, type_options)
+            Undumping.undump_field(dump.deep_dup, type_options)
           else
-            value.dup # date, datetime
+            value.deep_dup
           end
         end
       end

data/lib/dynamoid/dumping.rb

@@ -323,10 +323,10 @@ module Dynamoid
       def process(value)
         field_class = @options[:type]
 
-        if value.respond_to?(:dynamoid_dump)
-          value.dynamoid_dump
-        elsif field_class.respond_to?(:dynamoid_dump)
+        if field_class.respond_to?(:dynamoid_dump)
           field_class.dynamoid_dump(value)
+        elsif value.respond_to?(:dynamoid_dump)
+          value.dynamoid_dump
         else
           raise ArgumentError, "Neither #{field_class} nor #{value} supports serialization for Dynamoid."
         end

data/lib/dynamoid/errors.rb

@@ -86,10 +86,25 @@ module Dynamoid
 
     class UnsupportedKeyType < Error; end
 
-    class UnknownAttribute < Error; end
+    class UnknownAttribute < Error
+      attr_reader :model_class, :attribute_name
+
+      def initialize(model_class, attribute_name)
+        super("Attribute #{attribute_name} does not exist in #{model_class}")
+
+        @model_class = model_class
+        @attribute_name = attribute_name
+      end
+    end
 
     class SubclassNotFound < Error; end
 
     class Rollback < Error; end
+
+    class ScanProhibited < Error
+      def initialize(_msg = nil)
+        super('Scan operations prohibited. Modify Dynamoid::Config.error_on_scan to change this behavior.')
+      end
+    end
   end
 end

data/lib/dynamoid/fields/declare.rb

@@ -77,7 +77,7 @@ module Dynamoid
       end
 
       def warn_if_method_exists(method)
-        if @source.instance_methods.include?(method.to_sym)
+        if @source.method_defined?(method.to_sym)
           Dynamoid.logger.warn("Method #{method} generated for the field #{@name} overrides already existing method")
         end
       end