aws-record 2.10.1 → 2.12.0

data/lib/aws-record/record/table_migration.rb

@@ -3,10 +3,9 @@
 module Aws
   module Record
     class TableMigration
-
       # @!attribute [rw] client
       #   @return [Aws::DynamoDB::Client] the
-      #     {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html Aws::DynamoDB::Client}
+      #     {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html Aws::DynamoDB::Client}
       #     class used by this table migration instance.
       attr_accessor :client
 
@@ -14,19 +13,21 @@ module Aws
       # @param [Hash] opts
       # @option opts [Aws::DynamoDB::Client] :client Allows you to inject your
       #  own
-      #  {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html Aws::DynamoDB::Client}
+      #  {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html Aws::DynamoDB::Client}
       #  class. If this option is not included, a client will be constructed for
       #  you with default parameters.
       def initialize(model, opts = {})
         _assert_model_valid(model)
         @model = model
         @client = opts[:client] || model.dynamodb_client || Aws::DynamoDB::Client.new
+        @client.config.user_agent_frameworks << 'aws-record'
       end
 
       # This method calls
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#create_table-instance_method Aws::DynamoDB::Client#create_table},
-      # populating the attribute definitions and key schema based on your model
-      # class, as well as passing through other parameters as provided by you.
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#create_table-instance_method
+      # Aws::DynamoDB::Client#create_table}, populating the attribute definitions and
+      # key schema based on your model class, as well as passing through other
+      # parameters as provided by you.
       #
       # @example Creating a table with a global secondary index named +:gsi+
       #   migration.create!(
@@ -63,22 +64,20 @@ module Aws
         gsit = opts.delete(:global_secondary_index_throughput)
         _validate_billing(opts)
 
-        create_opts = opts.merge({
+        create_opts = opts.merge(
           table_name: @model.table_name,
           attribute_definitions: _attribute_definitions,
           key_schema: _key_schema
-        })
-        if lsis = @model.local_secondary_indexes_for_migration
+        )
+        if (lsis = @model.local_secondary_indexes_for_migration)
           create_opts[:local_secondary_indexes] = lsis
           _append_to_attribute_definitions(lsis, create_opts)
         end
-        if gsis = @model.global_secondary_indexes_for_migration
+        if (gsis = @model.global_secondary_indexes_for_migration)
           unless gsit || opts[:billing_mode] == 'PAY_PER_REQUEST'
-            raise ArgumentError.new(
-              'If you define global secondary indexes, you must also define'\
-                ' :global_secondary_index_throughput on table creation,'\
-                " unless :billing_mode is set to 'PAY_PER_REQUEST'."
-            )
+            raise ArgumentError, 'If you define global secondary indexes, you must also define ' \
+                                 ':global_secondary_index_throughput on table creation, ' \
+                                 "unless :billing_mode is set to 'PAY_PER_REQUEST'."
           end
           gsis_opts = if opts[:billing_mode] == 'PAY_PER_REQUEST'
                         gsis
@@ -92,8 +91,8 @@ module Aws
       end
 
       # This method calls
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#update_table-instance_method Aws::DynamoDB::Client#update_table}
-      # using the parameters that you provide.
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#update_table-instance_method
+      # Aws::DynamoDB::Client#update_table} using the parameters that you provide.
       #
       # @param [Hash] opts options to pass on to the client call to
       #  +#update_table+. See the documentation above in the AWS SDK for Ruby
@@ -101,28 +100,24 @@ module Aws
       # @raise [Aws::Record::Errors::TableDoesNotExist] if the table does not
       #  currently exist in Amazon DynamoDB.
       def update!(opts)
-        begin
-          update_opts = opts.merge({
-            table_name: @model.table_name
-          })
-          @client.update_table(update_opts)
-        rescue DynamoDB::Errors::ResourceNotFoundException => e
-          raise Errors::TableDoesNotExist.new(e)
-        end
+        update_opts = opts.merge(
+          table_name: @model.table_name
+        )
+        @client.update_table(update_opts)
+      rescue DynamoDB::Errors::ResourceNotFoundException
+        raise Errors::TableDoesNotExist
       end
 
       # This method calls
-      # {http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#delete_table-instance_method Aws::DynamoDB::Client#delete_table}
-      # using the table name of your model.
+      # {http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#delete_table-instance_method
+      # Aws::DynamoDB::Client#delete_table} using the table name of your model.
       #
       # @raise [Aws::Record::Errors::TableDoesNotExist] if the table did not
       #  exist in Amazon DynamoDB at the time of calling.
       def delete!
-        begin
-          @client.delete_table(table_name: @model.table_name)
-        rescue DynamoDB::Errors::ResourceNotFoundException => e
-          raise Errors::TableDoesNotExist.new(e)
-        end
+        @client.delete_table(table_name: @model.table_name)
+      rescue DynamoDB::Errors::ResourceNotFoundException
+        raise Errors::TableDoesNotExist
       end
 
       # This method waits on the table specified in the model to exist and be
@@ -134,46 +129,37 @@ module Aws
       end
 
       private
+
       def _assert_model_valid(model)
         _assert_required_include(model)
         model.model_valid?
       end
 
       def _assert_required_include(model)
-        unless model.include?(::Aws::Record)
-          raise Errors::InvalidModel.new("Table models must include Aws::Record")
-        end
+        return if model.include?(::Aws::Record)
+
+        raise Errors::InvalidModel, 'Table models must include Aws::Record'
       end
 
       def _validate_billing(opts)
         valid_modes = %w[PAY_PER_REQUEST PROVISIONED]
-        if opts.key?(:billing_mode)
-          unless valid_modes.include?(opts[:billing_mode])
-            raise ArgumentError.new(
-              ":billing_mode option must be one of #{valid_modes.join(', ')}"\
-                " current value is: #{opts[:billing_mode]}"
-            )
-          end
+        if opts.key?(:billing_mode) && !valid_modes.include?(opts[:billing_mode])
+          raise ArgumentError, ":billing_mode option must be one of #{valid_modes.join(', ')} " \
+                               "current value is: #{opts[:billing_mode]}"
         end
         if opts.key?(:provisioned_throughput)
           if opts[:billing_mode] == 'PAY_PER_REQUEST'
-            raise ArgumentError.new(
-              'when :provisioned_throughput option is specified, :billing_mode'\
-                " must either be unspecified or have a value of 'PROVISIONED'"
-            )
-          end
-        else
-          if opts[:billing_mode] != 'PAY_PER_REQUEST'
-            raise ArgumentError.new(
-              'when :provisioned_throughput option is not specified,'\
-                " :billing_mode must be set to 'PAY_PER_REQUEST'"
-            )
+            raise ArgumentError, 'when :provisioned_throughput option is specified, :billing_mode ' \
+                                 "must either be unspecified or have a value of 'PROVISIONED'"
           end
+        elsif opts[:billing_mode] != 'PAY_PER_REQUEST'
+          raise ArgumentError, 'when :provisioned_throughput option is not specified, ' \
+                               ":billing_mode must be set to 'PAY_PER_REQUEST'"
         end
       end
 
       def _attribute_definitions
-        _keys.map do |type, attr|
+        _keys.map do |_type, attr|
           {
             attribute_name: attr.database_name,
             attribute_type: attr.dynamodb_type
@@ -186,18 +172,18 @@ module Aws
         attr_def = create_opts[:attribute_definitions]
         secondary_indexes.each do |si|
           si[:key_schema].each do |key_schema|
-            exists = attr_def.find { |a|
+            exists = attr_def.find do |a|
               a[:attribute_name] == key_schema[:attribute_name]
-            }
-            unless exists
-              attr = attributes.attribute_for(
-                attributes.db_to_attribute_name(key_schema[:attribute_name])
-              )
-              attr_def << {
-                attribute_name: attr.database_name,
-                attribute_type: attr.dynamodb_type
-              }
             end
+            next if exists
+
+            attr = attributes.attribute_for(
+              attributes.db_to_attribute_name(key_schema[:attribute_name])
+            )
+            attr_def << {
+              attribute_name: attr.database_name,
+              attribute_type: attr.dynamodb_type
+            }
           end
         end
         create_opts[:attribute_definitions] = attr_def
@@ -212,12 +198,10 @@ module Aws
           params.merge(provisioned_throughput: throughput)
         end
         unless missing_throughput.empty?
-          raise ArgumentError.new(
-            "Missing provisioned throughput for the following global secondary"\
-              " indexes: #{missing_throughput.join(", ")}. GSIs:"\
-              " #{global_secondary_indexes} and defined throughput:"\
-              " #{gsi_throughput}"
-          )
+          raise ArgumentError, 'Missing provisioned throughput for the following global secondary ' \
+                               "indexes: #{missing_throughput.join(', ')}. GSIs: " \
+                               "#{global_secondary_indexes} and defined throughput: " \
+                               "#{gsi_throughput}"
         end
         ret
       end
@@ -226,13 +210,13 @@ module Aws
         _keys.map do |type, attr|
           {
             attribute_name: attr.database_name,
-            key_type: type == :hash ? "HASH" : "RANGE"
+            key_type: type == :hash ? 'HASH' : 'RANGE'
           }
         end
       end
 
       def _keys
-        @model.keys.inject({}) do |acc, (type, name)|
+        @model.keys.each_with_object({}) do |(type, name), acc|
           acc[type] = @model.attributes.attribute_for(name)
           acc
         end

data/lib/aws-record/record/transactions.rb

@@ -6,7 +6,6 @@ module Aws
       extend ClientConfiguration
 
       class << self
-
         # @example Usage Example
         #   class TableOne
         #     include Aws::Record
@@ -43,11 +42,11 @@ module Aws
         # * The aggregate size of the items in the transaction cannot exceed 4 MB.
         #
         # @param [Hash] opts Options to pass through to
-        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_get_items-instance_method Aws::DynamoDB::Client#transact_get_items},
-        #   with the exception of the +:transact_items+ array, which uses the
-        #   {ItemOperations.ItemOperationsClassMethods.tfind_opts #tfind_opts} operation
-        #   on your model class to provide extra metadata used to marshal your items
-        #   after retrieval.
+        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_get_items-instance_method
+        #   Aws::DynamoDB::Client#transact_get_items}, with the exception of the
+        #   +:transact_items+ array, which uses the {ItemOperations.ItemOperationsClassMethods.tfind_opts #tfind_opts}
+        #   operation on your model class to provide extra metadata
+        #   used to marshal your items after retrieval.
         # @option opts [Array] :transact_items A set of +#tfind_opts+ results,
         #   such as those created by the usage example.
         # @option opts [Aws::DynamoDB::Client] :client Optionally, you can pass
@@ -71,7 +70,6 @@ module Aws
           client_resp = client.transact_get_items(
             request_opts
           )
-          responses = client_resp.responses
           index = -1
           ret = OpenStruct.new
           ret.consumed_capacity = client_resp.consumed_capacity
@@ -187,11 +185,11 @@ module Aws
         # * There is a user error, such as an invalid data format.
         #
         # @param [Hash] opts Options to pass through to
-        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_write_items-instance_method Aws::DynamoDB::Client#transact_write_items}
-        #   with the exception of :transact_items array, which is transformed
-        #   to use your item to populate the :key, :table_name, :item, and/or
-        #   :update_expression parameters as appropriate. See the usage example
-        #   for a comprehensive set of combinations.
+        #   {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#transact_write_items-instance_method
+        #   Aws::DynamoDB::Client#transact_write_items} with the exception of
+        #   :transact_items array, which is transformed to use your item to populate
+        #   the :key, :table_name, :item, and/or :update_expression parameters
+        #   as appropriate. See the usage example for a comprehensive set of combinations.
         # @option opts [Array] :transact_items An array of hashes, accepting
         #   +:save+, +:put+, +:delete+, +:update+, and +:check+ as specified.
         # @option opts [Aws::DynamoDB::Client] :client Optionally, you can
@@ -212,35 +210,35 @@ module Aws
           opts[:transact_items] = transact_items
           resp = client.transact_write_items(opts)
           # mark all items clean/destroyed as needed if we didn't raise an exception
-          dirty_items.each { |i| i.clean! }
-          delete_items.each { |i| i.instance_variable_get("@data").destroyed = true }
+          dirty_items.each(&:clean!)
+          delete_items.each { |i| i.instance_variable_get('@data').destroyed = true }
           resp
         end
 
         private
+
         def _transform_transact_write_items(transact_items, dirty_items, delete_items)
           transact_items.map do |item|
             # this code will assume users only provided one operation, and
             # will fail down the line if that assumption is wrong
-            if save_record = item.delete(:save)
+            if (save_record = item.delete(:save))
               dirty_items << save_record
               _transform_save_record(save_record, item)
-            elsif put_record = item.delete(:put)
+            elsif (put_record = item.delete(:put))
               dirty_items << put_record
               _transform_put_record(put_record, item)
-            elsif delete_record = item.delete(:delete)
+            elsif (delete_record = item.delete(:delete))
               delete_items << delete_record
               _transform_delete_record(delete_record, item)
-            elsif update_record = item.delete(:update)
+            elsif (update_record = item.delete(:update))
               dirty_items << update_record
               _transform_update_record(update_record, item)
-            elsif check_record = item.delete(:check)
+            elsif (check_record = item.delete(:check))
               _transform_check_record(check_record, item)
             else
-              raise ArgumentError.new(
-                "Invalid transact write item, must include an operation of "\
-                  "type :save, :update, :delete, :update, or :check - #{item}"
-              )
+              raise ArgumentError, 'Invalid transact write item, must include an operation of ' \
+                                   "type :save, :update, :delete, :update, or :check - #{item}"
+
             end
           end
         end
@@ -251,16 +249,15 @@ module Aws
           if save_record.send(:expect_new_item?)
             safety_expression = save_record.send(:prevent_overwrite_expression)
             if opts.include?(:condition_expression)
-              raise Errors::TransactionalSaveConditionCollision.new(
-                "Transactional write includes a :save operation that would "\
-                  "result in a 'safe put' for the given item, yet a "\
-                  "condition expression was also provided. This is not "\
-                  "currently supported. You should rewrite this case to use "\
-                  "a :put transaction, adding the existence check to your "\
-                  "own condition expression if desired.\n"\
-                  "\tItem: #{JSON.pretty_unparse(save_record.to_h)}\n"\
-                  "\tExtra Options: #{JSON.pretty_unparse(opts)}"
-              )
+              raise Errors::TransactionalSaveConditionCollision,
+                    'Transactional write includes a :save operation that would ' \
+                    "result in a 'safe put' for the given item, yet a " \
+                    'condition expression was also provided. This is not ' \
+                    'currently supported. You should rewrite this case to use ' \
+                    'a :put transaction, adding the existence check to your ' \
+                    "own condition expression if desired.\n" \
+                    "\tItem: #{JSON.pretty_unparse(save_record.to_h)}\n" \
+                    "\tExtra Options: #{JSON.pretty_unparse(opts)}"
             else
               opts = opts.merge(safety_expression)
               _transform_put_record(save_record, opts)
@@ -296,16 +293,16 @@ module Aws
           opts[:key] = update_record.send(:key_values)
           opts[:update_expression] = uex
           # need to combine expression attribute names and values
-          if names = opts[:expression_attribute_names]
-            opts[:expression_attribute_names] = exp_attr_names.merge(names)
-          else
-            opts[:expression_attribute_names] = exp_attr_names
-          end
-          if values = opts[:expression_attribute_values]
-            opts[:expression_attribute_values] = exp_attr_values.merge(values)
-          else
-            opts[:expression_attribute_values] = exp_attr_values
-          end
+          opts[:expression_attribute_names] = if (names = opts[:expression_attribute_names])
+                                                exp_attr_names.merge(names)
+                                              else
+                                                exp_attr_names
+                                              end
+          opts[:expression_attribute_values] = if (values = opts[:expression_attribute_values])
+                                                 exp_attr_values.merge(values)
+                                               else
+                                                 exp_attr_values
+                                               end
           { update: opts }
         end
 

data/lib/aws-record/record/version.rb

@@ -2,6 +2,6 @@
 
 module Aws
   module Record
-    VERSION = File.read(File.expand_path('../../../../VERSION', __FILE__)).strip
+    VERSION = File.read(File.expand_path('../../../VERSION', __dir__)).strip
   end
 end

data/lib/aws-record/record.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Aws
-
   # +Aws::Record+ is the module you include in your model classes in order to
   # decorate them with the Amazon DynamoDB integration methods provided by this
   # library. Methods you can use are shown below, in sub-modules organized by
@@ -73,9 +72,7 @@ module Aws
       sub_class.send(:include, DirtyTracking)
       sub_class.send(:include, Query)
       sub_class.send(:include, SecondaryIndexes)
-      if Aws::Record.extends_record?(sub_class)
-        inherit_track_mutations(sub_class)
-      end
+      inherit_track_mutations(sub_class) if Aws::Record.extends_record?(sub_class)
     end
 
     # @api private
@@ -83,18 +80,21 @@ module Aws
       klass.superclass.include?(Aws::Record)
     end
 
+    # @api private
+    def self.inherit_track_mutations(klass)
+      superclass_track_mutations = klass.superclass.instance_variable_get('@track_mutations')
+      klass.instance_variable_set('@track_mutations', superclass_track_mutations)
+    end
+
+    private_class_method :inherit_track_mutations
+
     private
+
     def dynamodb_client
       self.class.dynamodb_client
     end
 
-    def self.inherit_track_mutations(klass)
-      superclass_track_mutations = klass.superclass.instance_variable_get("@track_mutations")
-      klass.instance_variable_set("@track_mutations", superclass_track_mutations)
-    end
-
     module RecordClassMethods
-
       # Returns the Amazon DynamoDB table name for this model class.
       #
       # By default, this will simply be the name of the class. However, you can
@@ -116,14 +116,15 @@ module Aws
       #   MyTable.table_name      # => "MyTable"
       #   MyOtherTable.table_name # => "test_MyTable"
       def table_name
-        @table_name ||= begin
-          if Aws::Record.extends_record?(self) &&
-              default_table_name(self.superclass) != self.superclass.table_name
-            self.superclass.instance_variable_get('@table_name')
-          else
-            default_table_name(self)
-          end
-        end
+        # rubocop:disable Style/RedundantSelf
+        @table_name ||= if Aws::Record.extends_record?(self) &&
+                           default_table_name(self.superclass) != self.superclass.table_name
+                          self.superclass.instance_variable_get('@table_name')
+                        else
+                          default_table_name(self)
+                        end
+
+        # rubocop:enable Style/RedundantSelf
       end
 
       # Allows you to set a custom Amazon DynamoDB table name for this model
@@ -175,7 +176,7 @@ module Aws
       #   end
       #
       #   Dog.table_name      # => "DogTable"
-      def set_table_name(name)
+      def set_table_name(name) # rubocop:disable Naming/AccessorMethodName
         @table_name = name
       end
 
@@ -187,32 +188,24 @@ module Aws
       # @raise [Aws::Record::Errors::TableDoesNotExist] if the table name does
       #   not exist in DynamoDB.
       def provisioned_throughput
-        begin
-          resp = dynamodb_client.describe_table(table_name: table_name)
-          throughput = resp.table.provisioned_throughput
-          return {
-            read_capacity_units: throughput.read_capacity_units,
-            write_capacity_units: throughput.write_capacity_units
-          }
-        rescue DynamoDB::Errors::ResourceNotFoundException
-          raise Record::Errors::TableDoesNotExist
-        end
+        resp = dynamodb_client.describe_table(table_name: table_name)
+        throughput = resp.table.provisioned_throughput
+        {
+          read_capacity_units: throughput.read_capacity_units,
+          write_capacity_units: throughput.write_capacity_units
+        }
+      rescue DynamoDB::Errors::ResourceNotFoundException
+        raise Record::Errors::TableDoesNotExist
       end
 
       # Checks if the model's table name exists in Amazon DynamoDB.
       #
       # @return [Boolean] true if the table does exist, false if it does not.
       def table_exists?
-        begin
-          resp = dynamodb_client.describe_table(table_name: table_name)
-          if resp.table.table_status == "ACTIVE"
-            true
-          else
-            false
-          end
-        rescue DynamoDB::Errors::ResourceNotFoundException
-          false
-        end
+        resp = dynamodb_client.describe_table(table_name: table_name)
+        resp.table.table_status == 'ACTIVE'
+      rescue DynamoDB::Errors::ResourceNotFoundException
+        false
       end
 
       # Turns off mutation tracking for all attributes in the model.
@@ -246,17 +239,16 @@ module Aws
       end
 
       def model_valid?
-        if @keys.hash_key.nil?
-          raise Errors::InvalidModel.new("Table models must include a hash key")
-        end
+        raise Errors::InvalidModel, 'Table models must include a hash key' if @keys.hash_key.nil?
       end
 
       private
+
       def default_table_name(klass)
         return unless klass.name
-        klass.name.split("::").join("_")
-      end
 
+        klass.name.split('::').join('_')
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-record
 version: !ruby/object:Gem::Version
-  version: 2.10.1
+  version: 2.12.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -16,18 +16,23 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.85.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.85.0
 description: Provides an object mapping abstraction for Amazon DynamoDB.
 email:
-- mamuller@amazon.com
-- alexwoo@amazon.com
+- aws-dr-rubygems@amazon.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -81,14 +86,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: AWS Record library for Amazon DynamoDB