aws-sdk-rails 3.8.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5157818d7cbed8369158102676415247809f388f88f255890c513705075193eb
-  data.tar.gz: 792018ac311693ce6afa82b8ae1c7547bf858a90959558f2547dcfc173cefdbe
+  metadata.gz: 79de6d1c1c8319fd70a36949eebb7630630bbd9b8a566b6f473d51590e48af38
+  data.tar.gz: a7d383cfecc470333c998f61ca380330dac77dc13dc5d302a5ba6bb34f8e5a81
 SHA512:
-  metadata.gz: 7c0821bb9dffd184a6f21c51bc6ed5a000dd1a1f5d0a435ccd5d36668f41d95f2be3e834482f20216b83edfac47d763c25d100386efcb87b9e8a64185b2644e9
-  data.tar.gz: be49eeaf3fa701769204a924dcfef6982360dc15387266a5d0e8ae8f8c1c44afb0b383669531799f8daabe2af65372ac37a7dbdf671ee9ba522ecd141a0f0ab8
+  metadata.gz: 95e0b8f6e3e565b6aeba24955bdbacff0a280de8c7f8a976a75ebadfd28710fc47c34c4fc079d95bb7d2678f60c185ec158719864eee0f8935424d4adb99d2e1
+  data.tar.gz: 95c7da0d1ac045139de0e1b4f251b1a118cadfa62a4eef3bfe8925df0e914325f7523fb3009cc3bb433828d4ea916f0c1e12b919a689931773317492a6811156

data/VERSION

@@ -1 +1 @@
-3.8.0
+3.9.0

data/bin/aws_sqs_active_job

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative '../lib/aws/rails/sqs_active_job/poller'
 

data/lib/action_dispatch/session/dynamodb_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sessionstore-dynamodb'
 require 'action_dispatch/middleware/session/abstract_store'
 
@@ -19,7 +21,7 @@ module ActionDispatch
       include SessionObject
 
       def initialize(app, options = {})
-        options[:config_file] ||= config_file if config_file.exist?
+        options[:config_file] ||= config_file if File.exist?(config_file)
         options[:secret_key] ||= Rails.application.secret_key_base
         super
       end
@@ -28,7 +30,7 @@ module ActionDispatch
 
       def config_file
         file = Rails.root.join("config/dynamo_db_session_store/#{Rails.env}.yml")
-        file = Rails.root.join('config/dynamo_db_session_store.yml') unless file.exist?
+        file = Rails.root.join('config/dynamo_db_session_store.yml') unless File.exist?(file)
         file
       end
     end

data/lib/active_job/queue_adapters/amazon_sqs_adapter.rb

@@ -4,9 +4,7 @@ require 'aws-sdk-sqs'
 
 module ActiveJob
   module QueueAdapters
-
     class AmazonSqsAdapter
-
       def enqueue(job)
         _enqueue(job)
       end
@@ -14,6 +12,7 @@ module ActiveJob
       def enqueue_at(job, timestamp)
         delay = (timestamp - Time.now.to_f).floor
         raise ArgumentError, 'Unable to queue a job with a delay great than 15 minutes' if delay > 15.minutes
+
         _enqueue(job, nil, delay_seconds: delay)
       end
 
@@ -27,11 +26,8 @@ module ActiveJob
         send_message_opts[:message_attributes] = message_attributes(job)
 
         if Aws::Rails::SqsActiveJob.fifo?(queue_url)
-          # job_id is unique per initialization of job
-          # Remove it from message dup id to ensure run-once behavior
-          # with ActiveJob retries
           send_message_opts[:message_deduplication_id] =
-            Digest::SHA256.hexdigest(Aws::Json.dump(body.except('job_id')))
+            Digest::SHA256.hexdigest(Aws::Json.dump(deduplication_body(job, body)))
 
           message_group_id = job.message_group_id if job.respond_to?(:message_group_id)
           message_group_id ||= Aws::Rails::SqsActiveJob.config.message_group_id
@@ -54,6 +50,13 @@ module ActiveJob
           }
         }
       end
+
+      def deduplication_body(job, body)
+        ex_dedup_keys = job.excluded_deduplication_keys if job.respond_to?(:excluded_deduplication_keys)
+        ex_dedup_keys ||= Aws::Rails::SqsActiveJob.config.excluded_deduplication_keys
+
+        body.except(*ex_dedup_keys)
+      end
     end
 
     # create an alias to allow `:amazon` to be used as the adapter name

data/lib/active_job/queue_adapters/amazon_sqs_async_adapter.rb

@@ -5,7 +5,6 @@ require 'concurrent'
 
 module ActiveJob
   module QueueAdapters
-
     # == Async adapter for Amazon SQS ActiveJob
     #
     # This adapter queues jobs asynchronously (ie non-blocking).  Error handler can be configured
@@ -15,7 +14,6 @@ module ActiveJob
     #
     # config.active_job.queue_adapter = :amazon_sqs_async
     class AmazonSqsAsyncAdapter < AmazonSqsAdapter
-
       private
 
       def _enqueue(job, body = nil, send_message_opts = {})

data/lib/aws/rails/notifications.rb

@@ -5,14 +5,12 @@ require 'active_support/notifications'
 
 module Aws
   module Rails
-
     # Instruments client operation calls for ActiveSupport::Notifications
     # Each client operation will produce an event with name:
     # <operation>.<service>.aws
     # @api private
     class Notifications < Seahorse::Client::Plugin
-
-      def add_handlers(handlers, config)
+      def add_handlers(handlers, _config)
         # This plugin needs to be first
         # which means it is called first in the stack, to start recording time,
         # and returns last
@@ -20,7 +18,6 @@ module Aws
       end
 
       class Handler < Seahorse::Client::Handler
-
         def call(context)
           event_name = "#{context.operation_name}.#{context.config.api.metadata['serviceId']}.aws"
           ActiveSupport::Notifications.instrument(event_name, context: context) do

data/lib/aws/rails/sqs_active_job/configuration.rb

@@ -3,7 +3,6 @@
 module Aws
   module Rails
     module SqsActiveJob
-
       # @return [Configuration] the (singleton) Configuration
       def self.config
         @config ||= Configuration.new
@@ -21,23 +20,25 @@ module Aws
       # Configuration for AWS SQS ActiveJob.
       # Use +Aws::Rails::SqsActiveJob.config+ to access the singleton config instance.
       class Configuration
-
         # Default configuration options
         # @api private
         DEFAULTS = {
-          max_messages:  10,
+          max_messages: 10,
           shutdown_timeout: 15,
           queues: {},
           logger: ::Rails.logger,
-          message_group_id: 'SqsActiveJobGroup'
-        }
+          message_group_id: 'SqsActiveJobGroup',
+          excluded_deduplication_keys: ['job_id']
+        }.freeze
 
         # @api private
         attr_accessor :queues, :max_messages, :visibility_timeout,
                       :shutdown_timeout, :client, :logger,
                       :async_queue_error_handler, :message_group_id
 
-        # Don't use this method directly: Confugration is a singleton class, use
+        attr_reader :excluded_deduplication_keys
+
+        # Don't use this method directly: Configuration is a singleton class, use
         # +Aws::Rails::SqsActiveJob.config+ to access the singleton config.
         #
         # @param [Hash] options
@@ -67,7 +68,7 @@ module Aws
         #   for the poller.
         #
         # @option options [String] :config_file
-        #   Override file to load configuration from.  If not specified will
+        #   Override file to load configuration from. If not specified will
         #   attempt to load from config/aws_sqs_active_job.yml.
         #
         # @option options [String] :message_group_id (SqsActiveJobGroup)
@@ -81,16 +82,25 @@ module Aws
         #   +active_job.queue_adapter = :amazon_sqs_async+.  Called with:
         #   [error, job, job_options]
         #
-        # @option options [SQS::Client] :client SQS Client to use.  A default
+        # @option options [SQS::Client] :client SQS Client to use. A default
         #   client will be created if none is provided.
+        #
+        # @option options [Array] :excluded_deduplication_keys (['job_id'])
+        #   The type of keys stored in the array should be String or Symbol.
+        #   Using this option, job_id is implicitly added to the keys.
+
         def initialize(options = {})
-          options[:config_file] ||= config_file if config_file.exist?
+          options[:config_file] ||= config_file if File.exist?(config_file)
           options = DEFAULTS
-             .merge(file_options(options))
-             .merge(options)
+                    .merge(file_options(options))
+                    .merge(options)
           set_attributes(options)
         end
 
+        def excluded_deduplication_keys=(keys)
+          @excluded_deduplication_keys = keys.map(&:to_s) | ['job_id']
+        end
+
         def client
           @client ||= begin
             client = Aws::SQS::Client.new
@@ -115,9 +125,9 @@ module Aws
         # @api private
         def to_h
           h = {}
-          self.instance_variables.each do |v|
+          instance_variables.each do |v|
             v_sym = v.to_s.gsub('@', '').to_sym
-            val = self.instance_variable_get(v)
+            val = instance_variable_get(v)
             h[v_sym] = val
           end
           h
@@ -127,7 +137,7 @@ module Aws
 
         # Set accessible attributes after merged options.
         def set_attributes(options)
-          options.keys.each do |opt_name|
+          options.each_key do |opt_name|
             instance_variable_set("@#{opt_name}", options[opt_name])
             client.config.user_agent_frameworks << 'aws-sdk-rails' if opt_name == :client
           end
@@ -144,7 +154,7 @@ module Aws
 
         def config_file
           file = ::Rails.root.join("config/aws_sqs_active_job/#{::Rails.env}.yml")
-          file = ::Rails.root.join('config/aws_sqs_active_job.yml') unless file.exist?
+          file = ::Rails.root.join('config/aws_sqs_active_job.yml') unless File.exist?(file)
           file
         end
 
@@ -156,20 +166,22 @@ module Aws
 
         # @return [String] Configuration path found in environment or YAML file.
         def config_file_path(options)
-          options[:config_file] || ENV["AWS_SQS_ACTIVE_JOB_CONFIG_FILE"]
+          options[:config_file] || ENV.fetch('AWS_SQS_ACTIVE_JOB_CONFIG_FILE', nil)
         end
 
         def load_yaml(file_path)
-          require "erb"
+          require 'erb'
           source = ERB.new(File.read(file_path)).result
 
           # Avoid incompatible changes with Psych 4.0.0
           # https://bugs.ruby-lang.org/issues/17866
+          # rubocop:disable Security/YAMLLoad
           begin
             YAML.load(source, aliases: true) || {}
           rescue ArgumentError
             YAML.load(source) || {}
           end
+          # rubocop:enable Security/YAMLLoad
         end
       end
     end

data/lib/aws/rails/sqs_active_job/deduplication.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Aws
+  module Rails
+    # SQS ActiveJob modules
+    module SqsActiveJob
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :excluded_deduplication_keys
+      end
+
+      # class methods for SQS ActiveJob.
+      module ClassMethods
+        def deduplicate_without(*keys)
+          self.excluded_deduplication_keys = keys.map(&:to_s) | ['job_id']
+        end
+      end
+    end
+  end
+end

data/lib/aws/rails/sqs_active_job/executor.rb

@@ -7,18 +7,17 @@ module Aws
     module SqsActiveJob
       # CLI runner for polling for SQS ActiveJobs
       class Executor
-
         DEFAULTS = {
-           min_threads:     0,
-           max_threads:     Concurrent.processor_count,
-           auto_terminate:  true,
-           idletime:        60, # 1 minute
-           fallback_policy: :caller_runs # slow down the producer thread
+          min_threads: 0,
+          max_threads: Concurrent.processor_count,
+          auto_terminate: true,
+          idletime: 60, # 1 minute
+          fallback_policy: :caller_runs # slow down the producer thread
         }.freeze
 
         def initialize(options = {})
           @executor = Concurrent::ThreadPoolExecutor.new(DEFAULTS.merge(options))
-          @logger = options[:logger] || ActiveSupport::Logger.new(STDOUT)
+          @logger = options[:logger] || ActiveSupport::Logger.new($stdout)
         end
 
         # TODO: Consider catching the exception and sleeping instead of using :caller_runs
@@ -40,16 +39,16 @@ module Aws
           end
         end
 
-        def shutdown(timeout=nil)
+        def shutdown(timeout = nil)
           @executor.shutdown
           clean_shutdown = @executor.wait_for_termination(timeout)
           if clean_shutdown
             @logger.info 'Clean shutdown complete.  All executing jobs finished.'
           else
-            @logger.info "Timeout (#{timeout}) exceeded.  Some jobs may not have"\
-              " finished cleanly.  Unfinished jobs will not be removed from"\
-              " the queue and can be ru-run once their visibility timeout"\
-              " passes."
+            @logger.info "Timeout (#{timeout}) exceeded.  Some jobs may not have " \
+                         'finished cleanly.  Unfinished jobs will not be removed from ' \
+                         'the queue and can be ru-run once their visibility timeout ' \
+                         'passes.'
           end
         end
       end

data/lib/aws/rails/sqs_active_job/job_runner.rb

@@ -3,7 +3,6 @@
 module Aws
   module Rails
     module SqsActiveJob
-
       class JobRunner
         attr_reader :id, :class_name
 

data/lib/aws/rails/sqs_active_job/lambda_handler.rb

@@ -5,7 +5,6 @@ require 'aws-sdk-sqs'
 module Aws
   module Rails
     module SqsActiveJob
-
       # A lambda event handler to run jobs from an SQS queue trigger
       # Trigger the lambda from your SQS queue
       # Configure the entrypoint to: +config/environment.Aws::Rails::SqsActiveJob.lambda_job_handler+
@@ -23,13 +22,11 @@ module Aws
         "Processed #{event['Records'].length} jobs."
       end
 
-      private
-
       def self.to_sqs_msg(record)
         msg = Aws::SQS::Types::Message.new(
           body: record['body'],
           md5_of_body: record['md5OfBody'],
-          message_attributes: self.to_message_attributes(record),
+          message_attributes: to_message_attributes(record),
           message_id: record['messageId'],
           receipt_handle: record['receiptHandle']
         )

data/lib/aws/rails/sqs_active_job/poller.rb

@@ -7,19 +7,17 @@ require 'concurrent'
 module Aws
   module Rails
     module SqsActiveJob
-
-      class Interrupt < Exception; end
+      class Interrupt < StandardError; end
 
       # CLI runner for polling for SQS ActiveJobs
       # Use `aws_sqs_active_job --help` for detailed usage
       class Poller
-
         DEFAULT_OPTS = {
-          threads: 2*Concurrent.processor_count,
+          threads: 2 * Concurrent.processor_count,
           max_messages: 10,
           shutdown_timeout: 15,
           backpressure: 10
-        }
+        }.freeze
 
         def initialize(args = ARGV)
           @options = parse_args(args)
@@ -28,7 +26,7 @@ module Aws
         end
 
         def set_environment
-          @environment = @options[:environment] || ENV["APP_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+          @environment = @options[:environment] || ENV['APP_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
         end
 
         def run
@@ -42,10 +40,9 @@ module Aws
                      .merge(@options.to_h)
           validate_config
           # ensure we have a logger configured
-          @logger = @options[:logger] || ActiveSupport::Logger.new(STDOUT)
+          @logger = @options[:logger] || ActiveSupport::Logger.new($stdout)
           @logger.info("Starting Poller with options=#{@options}")
 
-
           Signal.trap('INT') { raise Interrupt }
           Signal.trap('TERM') { raise Interrupt }
           @executor = Executor.new(max_threads: @options[:threads], logger: @logger, max_queue: @options[:backpressure])
@@ -78,9 +75,7 @@ module Aws
           # in order
           # Jobs with different message_group_id will be processed in
           # parallel and may be out of order.
-          if Aws::Rails::SqsActiveJob.fifo?(queue_url)
-            poller_options[:max_number_of_messages] = 1
-          end
+          poller_options[:max_number_of_messages] = 1 if Aws::Rails::SqsActiveJob.fifo?(queue_url)
 
           single_message = poller_options[:max_number_of_messages] == 1
 
@@ -89,35 +84,53 @@ module Aws
             @logger.info "Processing batch of #{msgs.length} messages"
             msgs.each do |msg|
               @executor.execute(Aws::SQS::Message.new(
-                queue_url: queue_url,
-                receipt_handle: msg.receipt_handle,
-                data: msg,
-                client: client
-              ))
+                                  queue_url: queue_url,
+                                  receipt_handle: msg.receipt_handle,
+                                  data: msg,
+                                  client: client
+                                ))
             end
           end
         end
 
         def boot_rails
           ENV['RACK_ENV'] = ENV['RAILS_ENV'] = @environment
-          require "rails"
-          require File.expand_path("config/environment.rb")
+          require 'rails'
+          require File.expand_path('config/environment.rb')
         end
 
         def parse_args(argv)
           out = {}
-          parser = ::OptionParser.new { |opts|
-            opts.on("-q", "--queue STRING", "[Required] Queue to poll") { |a| out[:queue] = a }
-            opts.on("-e", "--environment STRING", "Rails environment (defaults to development). You can also use the APP_ENV or RAILS_ENV environment variables to specify the environment.") { |a| out[:environment] = a }
-            opts.on("-t", "--threads INTEGER", Integer, "The maximum number of worker threads to create.  Defaults to 2x the number of processors available on this system.") { |a| out[:threads] = a }
-            opts.on("-b", "--backpressure INTEGER", Integer, "The maximum number of messages to have waiting in the Executor queue. This should be a low, but non zero number.  Messages in the Executor queue cannot be picked up by other processes and will slow down shutdown.") { |a| out[:backpressure] = a }
-            opts.on("-m", "--max_messages INTEGER", Integer, "Max number of messages to receive in a batch from SQS.") { |a| out[:max_messages] = a }
-            opts.on("-v", "--visibility_timeout INTEGER", Integer, "The visibility timeout is the number of seconds that a message will not be processable by any other consumers. You should set this value to be longer than your expected job runtime to prevent other processes from picking up an running job.  See the SQS Visibility Timeout Documentation at https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html.") { |a| out[:visibility_timeout] = a }
-            opts.on("-s", "--shutdown_timeout INTEGER", Integer, "The amount of time to wait for a clean shutdown.  Jobs that are unable to complete in this time will not be deleted from the SQS queue and will be retryable after the visibility timeout.") { |a| out[:shutdown_timeout] = a }
-          }
+          parser = ::OptionParser.new do |opts|
+            opts.on('-q', '--queue STRING', '[Required] Queue to poll') { |a| out[:queue] = a }
+            opts.on('-e', '--environment STRING',
+                    'Rails environment (defaults to development). You can also use the APP_ENV or RAILS_ENV environment variables to specify the environment.') do |a|
+              out[:environment] = a
+            end
+            opts.on('-t', '--threads INTEGER', Integer,
+                    'The maximum number of worker threads to create.  Defaults to 2x the number of processors available on this system.') do |a|
+              out[:threads] = a
+            end
+            opts.on('-b', '--backpressure INTEGER', Integer,
+                    'The maximum number of messages to have waiting in the Executor queue. This should be a low, but non zero number.  Messages in the Executor queue cannot be picked up by other processes and will slow down shutdown.') do |a|
+              out[:backpressure] = a
+            end
+            opts.on('-m', '--max_messages INTEGER', Integer,
+                    'Max number of messages to receive in a batch from SQS.') do |a|
+              out[:max_messages] = a
+            end
+            opts.on('-v', '--visibility_timeout INTEGER', Integer,
+                    'The visibility timeout is the number of seconds that a message will not be processable by any other consumers. You should set this value to be longer than your expected job runtime to prevent other processes from picking up an running job.  See the SQS Visibility Timeout Documentation at https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html.') do |a|
+              out[:visibility_timeout] = a
+            end
+            opts.on('-s', '--shutdown_timeout INTEGER', Integer,
+                    'The amount of time to wait for a clean shutdown.  Jobs that are unable to complete in this time will not be deleted from the SQS queue and will be retryable after the visibility timeout.') do |a|
+              out[:shutdown_timeout] = a
+            end
+          end
 
-          parser.banner = "aws_sqs_active_job [options]"
-          parser.on_tail "-h", "--help", "Show help" do
+          parser.banner = 'aws_sqs_active_job [options]'
+          parser.on_tail '-h', '--help', 'Show help' do
             puts parser
             exit 1
           end

data/lib/aws-sdk-rails.rb

@@ -5,6 +5,7 @@ require_relative 'aws/rails/sesv2_mailer'
 require_relative 'aws/rails/railtie'
 require_relative 'aws/rails/notifications'
 require_relative 'aws/rails/sqs_active_job/configuration'
+require_relative 'aws/rails/sqs_active_job/deduplication'
 require_relative 'aws/rails/sqs_active_job/executor'
 require_relative 'aws/rails/sqs_active_job/job_runner'
 require_relative 'aws/rails/sqs_active_job/lambda_handler'

data/lib/generators/aws_record/base.rb

@@ -1,217 +1,217 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 require_relative 'generated_attribute'
 require_relative 'secondary_index'
 
 module AwsRecord
-    module Generators
-      class Base < Rails::Generators::NamedBase
-        argument :attributes, type: :array, default: [], banner: "field[:type][:opts]...", desc: "Describes the fields in the model"
-        check_class_collision
-
-        class_option :disable_mutation_tracking, type: :boolean, desc: "Disables dirty tracking"
-        class_option :timestamps, type: :boolean, desc: "Adds created, updated timestamps to the model"
-        class_option :table_config, type: :hash, default: {}, banner: "primary:R-W [SecondaryIndex1:R-W]...", desc: "Declares the r/w units for the model as well as any secondary indexes", :required => true
-        class_option :gsi, type: :array, default: [], banner: "name:hkey{field_name}[,rkey{field_name},proj_type{ALL|KEYS_ONLY|INCLUDE}]...", desc: "Allows for the declaration of secondary indexes"
-        class_option :table_name, type: :string, banner: "model_table_name"
-        class_option :password_digest, type: :boolean, desc: "Whether to add a password_digest field to the model"
-
-        class_option :required, type: :string, banner: "field1...", desc: "A list of attributes that are required for an instance of the model"
-        class_option :length_validations, type: :hash, default: {}, banner: "field1:MIN-MAX...", desc: "Validations on the length of attributes in a model"
-
-        attr_accessor :primary_read_units, :primary_write_units, :gsi_rw_units, :gsis, :required_attrs, :length_validations
-
-        private
-
-        def initialize(args, *options)
-          options[0] << "--skip-table-config" if options[1][:behavior] == :revoke
-          @parse_errors = []
-
-          super
-          ensure_unique_fields
-          ensure_hkey
-          parse_gsis!
-          parse_table_config!
-          parse_validations!
-
-          if !@parse_errors.empty?
-            STDERR.puts "The following errors were encountered while trying to parse the given attributes"
-            STDERR.puts
-            STDERR.puts @parse_errors
-            STDERR.puts
-
-            abort("Please fix the errors before proceeding.")
-          end
-        end
-
-        def parse_attributes!
-
-          self.attributes = (attributes || []).map do |attr|
-            begin
-              GeneratedAttribute.parse(attr)
-            rescue ArgumentError => e
-              @parse_errors << e
-              next
-            end
-          end
-          self.attributes = self.attributes.compact
+  module Generators
+    class Base < Rails::Generators::NamedBase
+      argument :attributes, type: :array, default: [], banner: 'field[:type][:opts]...',
+                            desc: 'Describes the fields in the model'
+      check_class_collision
+
+      class_option :disable_mutation_tracking, type: :boolean, desc: 'Disables dirty tracking'
+      class_option :timestamps, type: :boolean, desc: 'Adds created, updated timestamps to the model'
+      class_option :table_config, type: :hash, default: {}, banner: 'primary:R-W [SecondaryIndex1:R-W]...',
+                                  desc: 'Declares the r/w units for the model as well as any secondary indexes', required: true
+      class_option :gsi, type: :array, default: [],
+                         banner: 'name:hkey{field_name}[,rkey{field_name},proj_type{ALL|KEYS_ONLY|INCLUDE}]...', desc: 'Allows for the declaration of secondary indexes'
+      class_option :table_name, type: :string, banner: 'model_table_name'
+      class_option :password_digest, type: :boolean, desc: 'Whether to add a password_digest field to the model'
+
+      class_option :required, type: :string, banner: 'field1...',
+                              desc: 'A list of attributes that are required for an instance of the model'
+      class_option :length_validations, type: :hash, default: {}, banner: 'field1:MIN-MAX...',
+                                        desc: 'Validations on the length of attributes in a model'
+
+      attr_accessor :primary_read_units, :primary_write_units, :gsi_rw_units, :gsis, :required_attrs,
+                    :length_validations
+
+      private
+
+      def initialize(args, *options)
+        options[0] << '--skip-table-config' if options[1][:behavior] == :revoke
+        @parse_errors = []
+
+        super
+        ensure_unique_fields
+        ensure_hkey
+        parse_gsis!
+        parse_table_config!
+        parse_validations!
+
+        return if @parse_errors.empty?
+
+        warn 'The following errors were encountered while trying to parse the given attributes'
+        $stderr.puts
+        warn @parse_errors
+        $stderr.puts
+
+        abort('Please fix the errors before proceeding.')
+      end
 
-          if options['password_digest']
-            self.attributes << GeneratedAttribute.new("password_digest", :string_attr, :digest => true)
+      def parse_attributes!
+        self.attributes = (attributes || []).map do |attr|
+          begin
+            GeneratedAttribute.parse(attr)
+          rescue ArgumentError => e
+            @parse_errors << e
+            next
           end
+        end
+        self.attributes = attributes.compact
 
-          if options['timestamps']
-            self.attributes << GeneratedAttribute.parse("created:datetime:default_value{Time.now}")
-            self.attributes << GeneratedAttribute.parse("updated:datetime:default_value{Time.now}")
-          end
+        if options['password_digest']
+          attributes << GeneratedAttribute.new('password_digest', :string_attr, digest: true)
         end
 
-        def ensure_unique_fields
-          used_names = Set.new
-          duplicate_fields = []
+        return unless options['timestamps']
 
-          self.attributes.each do |attr|
+        attributes << GeneratedAttribute.parse('created:datetime:default_value{Time.now}')
+        attributes << GeneratedAttribute.parse('updated:datetime:default_value{Time.now}')
+      end
 
-            if used_names.include? attr.name
-              duplicate_fields << [:attribute, attr.name]
-            end
-            used_names.add attr.name
+      def ensure_unique_fields
+        used_names = Set.new
+        duplicate_fields = []
 
-            if attr.options.key? :database_attribute_name
-              raw_db_attr_name = attr.options[:database_attribute_name].delete('"') # db attribute names are wrapped with " to make template generation easier
+        attributes.each do |attr|
+          duplicate_fields << [:attribute, attr.name] if used_names.include? attr.name
+          used_names.add attr.name
 
-              if used_names.include? raw_db_attr_name
-                duplicate_fields << [:database_attribute_name, raw_db_attr_name]
-              end
+          next unless attr.options.key? :database_attribute_name
 
-              used_names.add raw_db_attr_name
-            end
-          end
+          raw_db_attr_name = attr.options[:database_attribute_name].delete('"') # db attribute names are wrapped with " to make template generation easier
 
-          if !duplicate_fields.empty?
-            duplicate_fields.each do |invalid_attr|
-              @parse_errors << ArgumentError.new("Found duplicated field name: #{invalid_attr[1]}, in attribute#{invalid_attr[0]}")
-            end
-          end
+          duplicate_fields << [:database_attribute_name, raw_db_attr_name] if used_names.include? raw_db_attr_name
+
+          used_names.add raw_db_attr_name
         end
 
-        def ensure_hkey
-          uuid_member = nil
-          hkey_member = nil
-          rkey_member = nil
+        return if duplicate_fields.empty?
 
-          self.attributes.each do |attr|
-            if attr.options.key? :hash_key
-              if hkey_member
-                @parse_errors << ArgumentError.new("Redefinition of hash_key attr: #{attr.name}, original declaration of hash_key on: #{hkey_member.name}")
-                next
-              end
+        duplicate_fields.each do |invalid_attr|
+          @parse_errors << ArgumentError.new("Found duplicated field name: #{invalid_attr[1]}, in attribute#{invalid_attr[0]}")
+        end
+      end
 
-              hkey_member = attr
-            elsif attr.options.key? :range_key
-              if rkey_member
-                @parse_errors << ArgumentError.new("Redefinition of range_key attr: #{attr.name}, original declaration of range_key on: #{hkey_member.name}")
-                next
-              end
+      def ensure_hkey
+        uuid_member = nil
+        hkey_member = nil
+        rkey_member = nil
 
-              rkey_member = attr
+        attributes.each do |attr|
+          if attr.options.key? :hash_key
+            if hkey_member
+              @parse_errors << ArgumentError.new("Redefinition of hash_key attr: #{attr.name}, original declaration of hash_key on: #{hkey_member.name}")
+              next
             end
 
-            if attr.name.include? "uuid"
-              uuid_member = attr
+            hkey_member = attr
+          elsif attr.options.key? :range_key
+            if rkey_member
+              @parse_errors << ArgumentError.new("Redefinition of range_key attr: #{attr.name}, original declaration of range_key on: #{hkey_member.name}")
+              next
             end
-          end
 
-          if !hkey_member
-            if uuid_member
-              uuid_member.options[:hash_key] = true
-            else
-              self.attributes.unshift GeneratedAttribute.parse("uuid:hkey")
-            end
+            rkey_member = attr
           end
-        end
 
-        def mutation_tracking_disabled?
-          options['disable_mutation_tracking']
+          uuid_member = attr if attr.name.include? 'uuid'
         end
 
-        def has_validations?
-          !@required_attrs.empty? || !@length_validations.empty?
+        return if hkey_member
+
+        if uuid_member
+          uuid_member.options[:hash_key] = true
+        else
+          attributes.unshift GeneratedAttribute.parse('uuid:hkey')
         end
+      end
 
-        def parse_table_config!
-          return unless options['table_config']
+      def mutation_tracking_disabled?
+        options['disable_mutation_tracking']
+      end
 
-          @primary_read_units, @primary_write_units = parse_rw_units("primary")
+      def has_validations?
+        !@required_attrs.empty? || !@length_validations.empty?
+      end
 
-          @gsi_rw_units = @gsis.map { |idx|
-            [idx.name, parse_rw_units(idx.name)]
-          }.to_h
+      def parse_table_config!
+        return unless options['table_config']
 
-          options['table_config'].each do |config, rw_units|
-            if config == "primary"
-              next
-            else
-              gsi = @gsis.select { |idx| idx.name == config}
+        @primary_read_units, @primary_write_units = parse_rw_units('primary')
 
-              if gsi.empty?
-                @parse_errors << ArgumentError.new("Could not find a gsi declaration for #{config}")
-              end
-            end
-          end
+        @gsi_rw_units = @gsis.map do |idx|
+          [idx.name, parse_rw_units(idx.name)]
+        end.to_h
+
+        options['table_config'].each do |config, _rw_units|
+          next if config == 'primary'
+
+          gsi = @gsis.select { |idx| idx.name == config }
+
+          @parse_errors << ArgumentError.new("Could not find a gsi declaration for #{config}") if gsi.empty?
         end
+      end
 
-        def parse_rw_units(name)
-          if !options['table_config'].key? name
-            @parse_errors << ArgumentError.new("Please provide a table_config definition for #{name}")
-          else
-            rw_units = options['table_config'][name]
-            return rw_units.gsub(/[,.-]/, ':').split(':').reject { |s| s.empty? }
-          end
+      def parse_rw_units(name)
+        if options['table_config'].key? name
+          rw_units = options['table_config'][name]
+          rw_units.gsub(/[,.-]/, ':').split(':').reject(&:empty?)
+        else
+          @parse_errors << ArgumentError.new("Please provide a table_config definition for #{name}")
         end
+      end
 
-        def parse_gsis!
-          @gsis = (options['gsi'] || []).map do |raw_idx|
-            begin
-              idx = SecondaryIndex.parse(raw_idx)
+      def parse_gsis!
+        @gsis = (options['gsi'] || []).map do |raw_idx|
+          begin
+            idx = SecondaryIndex.parse(raw_idx)
 
-              attributes = self.attributes.select { |attr| attr.name == idx.hash_key}
+            attributes = self.attributes.select { |attr| attr.name == idx.hash_key }
+            if attributes.empty?
+              @parse_errors << ArgumentError.new("Could not find attribute #{idx.hash_key} for gsi #{idx.name} hkey")
+              next
+            end
+
+            if idx.range_key
+              attributes = self.attributes.select { |attr| attr.name == idx.range_key }
               if attributes.empty?
-                @parse_errors << ArgumentError.new("Could not find attribute #{idx.hash_key} for gsi #{idx.name} hkey")
+                @parse_errors << ArgumentError.new("Could not find attribute #{idx.range_key} for gsi #{idx.name} rkey")
                 next
               end
-
-              if idx.range_key
-                attributes = self.attributes.select { |attr| attr.name == idx.range_key}
-                if attributes.empty?
-                  @parse_errors << ArgumentError.new("Could not find attribute #{idx.range_key} for gsi #{idx.name} rkey")
-                  next
-                end
-              end
-
-              idx
-            rescue ArgumentError => e
-              @parse_errors << e
-              next
             end
-          end
 
-          @gsis = @gsis.compact
+            idx
+          rescue ArgumentError => e
+            @parse_errors << e
+            next
+          end
         end
 
-        def parse_validations!
-          @required_attrs = options['required'] ? options['required'].split(',') : []
-          @required_attrs.each do |val_attr|
-            @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if !self.attributes.any? { |attr| attr.name == val_attr }
-          end
+        @gsis = @gsis.compact
+      end
 
-          @length_validations = options['length_validations'].map do |val_attr, bounds|
-            @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if !self.attributes.any? { |attr| attr.name == val_attr }
+      def parse_validations!
+        @required_attrs = options['required'] ? options['required'].split(',') : []
+        @required_attrs.each do |val_attr|
+          @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if attributes.none? do |attr|
+                                                                                                       attr.name == val_attr
+                                                                                                     end
+        end
 
-            bounds = bounds.gsub(/[,.-]/, ':').split(':').reject { |s| s.empty? }
-            [val_attr, "#{bounds[0]}..#{bounds[1]}"]
-          end
-          @length_validations = @length_validations.to_h
+        @length_validations = options['length_validations'].map do |val_attr, bounds|
+          @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if attributes.none? do |attr|
+                                                                                                       attr.name == val_attr
+                                                                                                     end
+
+          bounds = bounds.gsub(/[,.-]/, ':').split(':').reject(&:empty?)
+          [val_attr, "#{bounds[0]}..#{bounds[1]}"]
         end
+        @length_validations = @length_validations.to_h
       end
     end
   end
+end

data/lib/generators/aws_record/generated_attribute.rb

@@ -1,28 +1,31 @@
+# frozen_string_literal: true
+
 module AwsRecord
   module Generators
     class GeneratedAttribute
-
-      OPTS = %w(hkey rkey persist_nil db_attr_name ddb_type default_value)
-      INVALID_HKEY_TYPES = %i(map_attr list_attr numeric_set_attr string_set_attr)
+      OPTS = %w[hkey rkey persist_nil db_attr_name ddb_type default_value].freeze
+      INVALID_HKEY_TYPES = %i[map_attr list_attr numeric_set_attr string_set_attr].freeze
       attr_reader :name, :type
       attr_accessor :options
 
       def field_type
         case @type
-          when :integer_attr then :number_field
-          when :date_attr then :date_select
-          when :datetime_attr then :datetime_select
-          when :boolean_attr then :check_box
-          else :text_field
+        when :integer_attr then :number_field
+        when :date_attr then :date_select
+        when :datetime_attr then :datetime_select
+        when :boolean_attr then :check_box
+        else :text_field
         end
       end
 
       class << self
-
         def parse(field_definition)
           name, type, opts = field_definition.split(':')
-          type = "string" if not type
-          type, opts = "string", type if OPTS.any? { |opt| type.include? opt }
+          type ||= 'string'
+          if OPTS.any? { |opt| type.include? opt }
+            opts = type
+            type = 'string'
+          end
 
           opts = opts.split(',') if opts
           type, opts = parse_type_and_options(name, type, opts)
@@ -34,65 +37,71 @@ module AwsRecord
         private
 
         def validate_opt_combs(name, type, opts)
-          if opts
-              is_hkey = opts.key?(:hash_key)
-              is_rkey = opts.key?(:range_key)
+          return unless opts
+
+          is_hkey = opts.key?(:hash_key)
+          is_rkey = opts.key?(:range_key)
 
-              raise ArgumentError.new("Field #{name} cannot be a range key and hash key simultaneously") if is_hkey && is_rkey
-              raise ArgumentError.new("Field #{name} cannot be a hash key and be of type #{type}") if is_hkey and INVALID_HKEY_TYPES.include? type
+          if is_hkey && is_rkey
+            raise ArgumentError,
+                  "Field #{name} cannot be a range key and hash key simultaneously"
           end
+          return unless is_hkey && INVALID_HKEY_TYPES.include?(type)
+
+          raise ArgumentError,
+                "Field #{name} cannot be a hash key and be of type #{type}"
         end
 
         def parse_type_and_options(name, type, opts)
-          opts = [] if not opts
-          return parse_type(name, type), opts.map { |opt| parse_option(name, opt) }.to_h
+          opts ||= []
+          [parse_type(name, type), opts.map { |opt| parse_option(name, opt) }.to_h]
         end
 
         def parse_option(name, opt)
           case opt
 
-          when "hkey"
-            return :hash_key, true
-          when "rkey"
-            return :range_key, true
-          when "persist_nil"
-            return :persist_nil, true
+          when 'hkey'
+            [:hash_key, true]
+          when 'rkey'
+            [:range_key, true]
+          when 'persist_nil'
+            [:persist_nil, true]
           when /db_attr_name\{(\w+)\}/
-            return :database_attribute_name, '"' + $1 + '"'
+            [:database_attribute_name, "\"#{::Regexp.last_match(1)}\""]
           when /ddb_type\{(S|N|B|BOOL|SS|NS|BS|M|L)\}/i
-            return :dynamodb_type, '"' + $1.upcase + '"'
+            [:dynamodb_type, "\"#{::Regexp.last_match(1).upcase}\""]
           when /default_value\{(.+)\}/
-            return :default_value, $1
+            [:default_value, ::Regexp.last_match(1)]
           else
-            raise ArgumentError.new("You provided an invalid option for #{name}: #{opt}")
+            raise ArgumentError, "You provided an invalid option for #{name}: #{opt}"
           end
         end
 
         def parse_type(name, type)
           case type.downcase
 
-          when "bool", "boolean"
+          when 'bool', 'boolean'
             :boolean_attr
-          when "date"
+          when 'date'
             :date_attr
-          when "datetime"
+          when 'datetime'
             :datetime_attr
-          when "float"
+          when 'float'
             :float_attr
-          when "int", "integer"
+          when 'int', 'integer'
             :integer_attr
-          when "list"
+          when 'list'
             :list_attr
-          when "map"
+          when 'map'
             :map_attr
-          when "num_set", "numeric_set", "nset"
+          when 'num_set', 'numeric_set', 'nset'
             :numeric_set_attr
-          when "string_set", "s_set", "sset"
+          when 'string_set', 's_set', 'sset'
             :string_set_attr
-          when "string"
+          when 'string'
             :string_attr
           else
-            raise ArgumentError.new("Invalid type for #{name}: #{type}")
+            raise ArgumentError, "Invalid type for #{name}: #{type}"
           end
         end
       end
@@ -114,8 +123,8 @@ module AwsRecord
       end
 
       def column_name
-        if @name == "password_digest"
-          "password"
+        if @name == 'password_digest'
+          'password'
         else
           @name
         end

data/lib/generators/aws_record/model/model_generator.rb

@@ -1,21 +1,25 @@
+# frozen_string_literal: true
+
 require_relative '../base'
 
 module AwsRecord
   module Generators
     class ModelGenerator < Base
       def initialize(args, *options)
-        self.class.source_root File.expand_path('../templates', __FILE__)
+        self.class.source_root File.expand_path('templates', __dir__)
         super
       end
 
       def create_model
-        template "model.erb", File.join("app/models", class_path, "#{file_name}.rb")
+        template 'model.erb', File.join('app/models', class_path, "#{file_name}.rb")
       end
 
       def create_table_config
-        template "table_config.erb", File.join("db/table_config", class_path, "#{file_name}_config.rb") if options["table_config"]
-      end
+        return unless options['table_config']
 
+        template 'table_config.erb',
+                 File.join('db/table_config', class_path, "#{file_name}_config.rb")
+      end
     end
   end
 end

data/lib/generators/aws_record/secondary_index.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module AwsRecord
   module Generators
     class SecondaryIndex
-
-      PROJ_TYPES = %w(ALL KEYS_ONLY INCLUDE)
+      PROJ_TYPES = %w[ALL KEYS_ONLY INCLUDE].freeze
       attr_reader :name, :hash_key, :range_key, :projection_type
 
       class << self
@@ -15,45 +16,50 @@ module AwsRecord
         end
 
         private
-          def parse_raw_options(raw_opts)
-            raw_opts = [] if not raw_opts
-            raw_opts.map { |opt| get_option_value(opt) }.to_h
-          end
 
-          def get_option_value(raw_option)
-            case raw_option
-
-            when /hkey\{(\w+)\}/
-              return :hash_key, $1
-            when /rkey\{(\w+)\}/
-              return :range_key, $1
-            when /proj_type\{(\w+)\}/
-              return :projection_type, $1
-            else
-              raise ArgumentError.new("Invalid option for secondary index #{raw_option}")
-            end
+        def parse_raw_options(raw_opts)
+          raw_opts ||= []
+          raw_opts.map { |opt| get_option_value(opt) }.to_h
+        end
+
+        def get_option_value(raw_option)
+          case raw_option
+
+          when /hkey\{(\w+)\}/
+            [:hash_key, ::Regexp.last_match(1)]
+          when /rkey\{(\w+)\}/
+            [:range_key, ::Regexp.last_match(1)]
+          when /proj_type\{(\w+)\}/
+            [:projection_type, ::Regexp.last_match(1)]
+          else
+            raise ArgumentError, "Invalid option for secondary index #{raw_option}"
           end
+        end
       end
 
       def initialize(name, opts)
-        raise ArgumentError.new("You must provide a name") if not name
-        raise ArgumentError.new("You must provide a hash key") if not opts[:hash_key]
+        raise ArgumentError, 'You must provide a name' unless name
+        raise ArgumentError, 'You must provide a hash key' unless opts[:hash_key]
 
         if opts.key? :projection_type
-          raise ArgumentError.new("Invalid projection type #{opts[:projection_type]}") if not PROJ_TYPES.include? opts[:projection_type]
-          raise NotImplementedError.new("ALL is the only projection type currently supported") if opts[:projection_type] != "ALL"
+          unless PROJ_TYPES.include? opts[:projection_type]
+            raise ArgumentError, "Invalid projection type #{opts[:projection_type]}"
+          end
+          if opts[:projection_type] != 'ALL'
+            raise NotImplementedError, 'ALL is the only projection type currently supported'
+          end
         else
-          opts[:projection_type] = "ALL"
+          opts[:projection_type] = 'ALL'
         end
 
         if opts[:hash_key] == opts[:range_key]
-          raise ArgumentError.new("#{opts[:hash_key]} cannot be both the rkey and hkey for gsi #{name}")
+          raise ArgumentError, "#{opts[:hash_key]} cannot be both the rkey and hkey for gsi #{name}"
         end
 
         @name = name
         @hash_key = opts[:hash_key]
         @range_key = opts[:range_key]
-        @projection_type = '"' + "#{opts[:projection_type]}" + '"'
+        @projection_type = "\"#{opts[:projection_type]}\""
       end
     end
   end

data/lib/generators/dynamo_db/session_store_migration/session_store_migration_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/generators/named_base'
 
 # This class generates a migration file for deleting and creating

data/lib/tasks/aws_record/migrate.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 desc 'Run all table configs in table_config folder'
 namespace :aws_record do
   task migrate: :environment do

data/lib/tasks/dynamo_db/session_store.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace 'dynamo_db' do
   namespace 'session_store' do
     desc 'Clean up old sessions in the Amazon DynamoDB session store table.'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-rails
 version: !ruby/object:Gem::Version
-  version: 3.8.0
+  version: 3.9.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-02 00:00:00.000000000 Z
+date: 2023-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-record
@@ -99,33 +99,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: railties
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: '1'
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -142,8 +142,7 @@ dependencies:
         version: '0'
 description: Integrates the AWS Ruby SDK with Ruby on Rails
 email:
-- mamuller@amazon.com
-- alexwoo@amazon.com
+- aws-dr-rubygems@amazon.com
 executables:
 - aws_sqs_active_job
 extensions: []
@@ -161,6 +160,7 @@ files:
 - lib/aws/rails/ses_mailer.rb
 - lib/aws/rails/sesv2_mailer.rb
 - lib/aws/rails/sqs_active_job/configuration.rb
+- lib/aws/rails/sqs_active_job/deduplication.rb
 - lib/aws/rails/sqs_active_job/executor.rb
 - lib/aws/rails/sqs_active_job/job_runner.rb
 - lib/aws/rails/sqs_active_job/lambda_handler.rb
@@ -190,7 +190,7 @@ 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:
   - - ">="