aws-record 2.1.1 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3d5eae4de88bc967f473b49bf9294047a6ee6821
-  data.tar.gz: 5c2e4404ad3b47f909d572b546f3cd70a8e0e93d
+SHA256:
+  metadata.gz: d017802e3f3023427a79e39fe59468a66f1fe138ef3a6bd173bdcc4d4a15c05c
+  data.tar.gz: c9efe98e3226977a5c381d16cf0dd9ffcd77e6c99d7d4407d58c2e20908c5be2
 SHA512:
-  metadata.gz: c261673f84aa256222fdd9c17f715ab9161c1a1a1fd23978b494c62627312d12dd314d824321ef43296f87fe92be35ab135de104b6094bb753b746fe3e7235f6
-  data.tar.gz: 7742ea625d83be44c72602f0d55b05f7614f87971cd69bcb402f02de0e7c55057b9870a77b43b0d2adfe02f428565b7be7e770317ba9220bc8b2386528306750
+  metadata.gz: 0fd56a56605143708ee9f70074317452105860f86835f59653e484c0b1f700b9a7e587383fb9a9278c1eb3c0585cb6fde1024d07bf3d6bcefc1497fcd9ab5984
+  data.tar.gz: ba3f5889ca0954c294ca77b752ab45cb7151067c81369b3b303c86f72e32bc2f0eb7496ca6ccdfbfbf515ef6d04c1809cf32f839cc3574d35ff1f965646505a9

data/lib/aws-record.rb

@@ -27,6 +27,8 @@ require_relative 'aws-record/record/secondary_indexes'
 require_relative 'aws-record/record/table_config'
 require_relative 'aws-record/record/table_migration'
 require_relative 'aws-record/record/version'
+require_relative 'aws-record/record/transactions'
+require_relative 'aws-record/record/buildable_search'
 require_relative 'aws-record/record/marshalers/string_marshaler'
 require_relative 'aws-record/record/marshalers/boolean_marshaler'
 require_relative 'aws-record/record/marshalers/integer_marshaler'

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

@@ -48,12 +48,14 @@ module Aws
       #   item is nil or not set at persistence time.
       def initialize(name, options = {})
         @name = name
-        @database_name = options[:database_attribute_name] || name.to_s
+        @database_name = (options[:database_attribute_name]  || name).to_s
         @dynamodb_type = options[:dynamodb_type]
         @marshaler = options[:marshaler] || DefaultMarshaler
         @persist_nil = options[:persist_nil]
         dv = options[:default_value]
-        @default_value_or_lambda = type_cast(dv) unless dv.nil?
+        unless dv.nil?
+          @default_value_or_lambda = _is_lambda?(dv) ? dv : type_cast(dv)
+        end
       end
 
       # Attempts to type cast a raw value into the attribute's type. This call
@@ -92,8 +94,8 @@ module Aws
 
       # @api private
       def default_value
-        if @default_value_or_lambda.respond_to?(:call)
-          @default_value_or_lambda.call
+        if _is_lambda?(@default_value_or_lambda)
+          type_cast(@default_value_or_lambda.call)
         else
           _deep_copy(@default_value_or_lambda)
         end
@@ -104,6 +106,10 @@ module Aws
         Marshal.load(Marshal.dump(obj))
       end
 
+      def _is_lambda?(obj)
+        obj.respond_to?(:call)
+      end
+
     end
 
     # This is an identity marshaler, which performs no changes for type casting

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

@@ -0,0 +1,232 @@
+module Aws
+  module Record
+    class BuildableSearch
+      SUPPORTED_OPERATIONS = [:query, :scan]
+
+      # This should never be called directly, rather it is called by the
+      # #build_query or #build_scan methods of your aws-record model class.
+      def initialize(opts)
+        operation = opts[:operation]
+        model = opts[:model]
+        if SUPPORTED_OPERATIONS.include?(operation)
+          @operation = operation
+        else
+          raise ArgumentError.new("Unsupported operation: #{operation}")
+        end
+        @model = model
+        @params = {}
+        @next_name = "BUILDERA"
+        @next_value = "buildera"
+      end
+
+      # If you are querying or scanning on an index, you can specify it with
+      # this builder method. Provide the symbol of your index as defined on your
+      # model class.
+      def on_index(index)
+        @params[:index_name] = index
+        self
+      end
+
+      # If true, will perform your query or scan as a consistent read. If false,
+      # the query or scan is eventually consistent.
+      def consistent_read(b)
+        @params[:consistent_read] = b
+        self
+      end
+
+      # For the scan operation, you can split your scan into multiple segments
+      # to be scanned in parallel. If you wish to do this, you can use this
+      # builder method to provide the :total_segments of your parallel scan and
+      # the :segment number of this scan.
+      def parallel_scan(opts)
+        unless @operation == :scan
+          raise ArgumentError.new("parallel_scan is only supported for scans")
+        end
+        unless opts[:total_segments] && opts[:segment]
+          raise ArgumentError.new("Must specify :total_segments and :segment in a parallel scan.")
+        end
+        @params[:total_segments] = opts[:total_segments]
+        @params[:segment] = opts[:segment]
+        self
+      end
+
+      # For a query operation, you can use this to set if you query is in
+      # ascending or descending order on your range key. By default, a query is
+      # run in ascending order.
+      def scan_ascending(b)
+        unless @operation == :query
+          raise ArgumentError.new("scan_ascending is only supported for queries.")
+        end
+        @params[:scan_index_forward] = b
+        self
+      end
+
+      # If you have an exclusive start key for your query or scan, you can
+      # provide it with this builder method. You should not use this if you are
+      # querying or scanning without a set starting point, as the
+      # {Aws::Record::ItemCollection} class handles pagination automatically
+      # for you.
+      def exclusive_start_key(key)
+        @params[:exclusive_start_key] = key
+        self
+      end
+
+      # Provide a key condition expression for your query using a substitution
+      # expression.
+      #
+      # @example Building a simple query with a key expression:
+      #   # Example model class
+      #   class ExampleTable
+      #     include Aws::Record
+      #     string_attr  :uuid, hash_key: true
+      #     integer_attr :id,   range_key: true
+      #     string_attr  :body
+      #   end
+      #
+      #   q = ExampleTable.build_query.key_expr(
+      #         ":uuid = ? AND :id > ?", "smpl-uuid", 100
+      #       ).complete!
+      #   q.to_a # You can use this like any other query result in aws-record
+      def key_expr(statement_str, *subs)
+        unless @operation == :query
+          raise ArgumentError.new("key_expr is only supported for queries.")
+        end
+        names = @params[:expression_attribute_names]
+        if names.nil?
+          @params[:expression_attribute_names] = {}
+          names = @params[:expression_attribute_names]
+        end
+        values = @params[:expression_attribute_values]
+        if values.nil?
+          @params[:expression_attribute_values] = {}
+          values = @params[:expression_attribute_values]
+        end
+        _key_pass(statement_str, names)
+        _apply_values(statement_str, subs, values)
+        @params[:key_condition_expression] = statement_str
+        self
+      end
+
+      # Provide a filter expression for your query or scan using a substitution
+      # expression.
+      #
+      # @example Building a simple scan:
+      #   # Example model class
+      #   class ExampleTable
+      #     include Aws::Record
+      #     string_attr  :uuid, hash_key: true
+      #     integer_attr :id,   range_key: true
+      #     string_attr  :body
+      #   end
+      #
+      #   scan = ExampleTable.build_scan.filter_expr(
+      #     "contains(:body, ?)",
+      #     "bacon"
+      #   ).complete!
+      # 
+      def filter_expr(statement_str, *subs)
+        names = @params[:expression_attribute_names]
+        if names.nil?
+          @params[:expression_attribute_names] = {}
+          names = @params[:expression_attribute_names]
+        end
+        values = @params[:expression_attribute_values]
+        if values.nil?
+          @params[:expression_attribute_values] = {}
+          values = @params[:expression_attribute_values]
+        end
+        _key_pass(statement_str, names)
+        _apply_values(statement_str, subs, values)
+        @params[:filter_expression] = statement_str
+        self
+      end
+
+      # Allows you to define a projection expression for the values returned by
+      # a query or scan. See
+      # {https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html the Amazon DynamoDB Developer Guide}
+      # for more details on projection expressions. You can use the symbols from
+      # your aws-record model class in a projection expression. Keys are always
+      # retrieved.
+      #
+      # @example Scan with a projection expression:
+      #   # Example model class
+      #   class ExampleTable
+      #     include Aws::Record
+      #     string_attr  :uuid, hash_key: true
+      #     integer_attr :id,   range_key: true
+      #     string_attr  :body
+      #     map_attr     :metadata
+      #   end
+      #
+      #   scan = ExampleTable.build_scan.projection_expr(
+      #     ":body"
+      #   ).complete!
+      def projection_expr(statement_str)
+        names = @params[:expression_attribute_names]
+        if names.nil?
+          @params[:expression_attribute_names] = {}
+          names = @params[:expression_attribute_names]
+        end
+        _key_pass(statement_str, names)
+        @params[:projection_expression] = statement_str
+        self
+      end
+
+      # Allows you to set a page size limit on each query or scan request.
+      def limit(size)
+        @params[:limit] = size
+        self
+      end
+
+      # You must call this method at the end of any query or scan you build.
+      #
+      # @return [Aws::Record::ItemCollection] The item collection lazy
+      #   enumerable.
+      def complete!
+        @model.send(@operation, @params)
+      end
+
+      private
+      def _key_pass(statement, names)
+        statement.gsub!(/:(\w+)/) do |match|
+          key = match.gsub!(':','').to_sym 
+          key_name = @model.attributes.storage_name_for(key)
+          if key_name
+            sub_name = _next_name
+            raise "Substitution collision!" if names[sub_name]
+            names[sub_name] = key_name
+            sub_name
+          else
+            raise "No such key #{key}"
+          end
+        end
+      end
+
+      def _apply_values(statement, subs, values)
+        count = 0
+        statement.gsub!(/[?]/) do |match|
+          sub_value = _next_value
+          raise "Substitution collision!" if values[sub_value]
+          values[sub_value] = subs[count]
+          count += 1
+          sub_value
+        end
+        unless count == subs.size
+          raise "Expected #{count} values in the substitution set, but found #{subs.size}"
+        end
+      end
+
+      def _next_name
+        ret = "#" + @next_name
+        @next_name.next!
+        ret
+      end
+
+      def _next_value
+        ret = ":" + @next_value
+        @next_value.next!
+        ret
+      end
+    end
+  end
+end

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

@@ -54,6 +54,14 @@ module Aws
       class TableDoesNotExist < RuntimeError; end
 
       class MissingRequiredConfiguration < RuntimeError; end
+
+      # Raised when you attempt to combine your own condition expression with
+      # the auto-generated condition expression from a "safe put" from saving
+      # a new item in a transactional write operation. The path forward until
+      # this case is supported is to use a plain "put" call, and to include
+      # the key existance check yourself in your condition expression if you
+      # wish to do so.
+      class TransactionalSaveConditionCollision < RuntimeError; end
     end
   end
 end

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

@@ -122,9 +122,9 @@ module Aws
 
       def populate_default_values
         @model_attributes.attributes.each do |name, attribute|
-          unless attribute.default_value.nil?
+          unless (default_value = attribute.default_value).nil?
             if @data[name].nil? && @data[name].nil?
-              @data[name] = attribute.default_value
+              @data[name] = default_value
             end
           end
         end

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

@@ -329,6 +329,112 @@ module Aws
 
       module ItemOperationsClassMethods
 
+        # @example Usage Example
+        #   check_exp = Model.transact_check_expression(
+        #     key: { uuid: "foo" },
+        #     condition_expression: "size(#T) <= :v",
+        #     expression_attribute_names: {
+        #       "#T" => "body"
+        #     },
+        #     expression_attribute_values: {
+        #       ":v" => 1024
+        #     }
+        #   )
+        # 
+        # Allows you to build a "check" expression for use in transactional
+        # write operations.
+        #
+        # @param [Hash] opts Options matching the :condition_check contents in
+        #   the
+        #   {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}
+        #   API, with the exception that keys will be marshalled for you, and
+        #   the table name will be provided for you by the operation.
+        # @return [Hash] Options suitable to be used as a check expression when
+        #   calling the +#transact_write+ operation.
+        def transact_check_expression(opts)
+          # need to transform the key, and add the table name
+          opts = opts.dup
+          key = opts.delete(:key)
+          check_key = {}
+          @keys.keys.each_value do |attr_sym|
+            unless key[attr_sym]
+              raise Errors::KeyMissing.new(
+                "Missing required key #{attr_sym} in #{key}"
+              )
+            end
+            attr_name = attributes.storage_name_for(attr_sym)
+            check_key[attr_name] = attributes.attribute_for(attr_sym).
+              serialize(key[attr_sym])
+          end
+          opts[:key] = check_key
+          opts[:table_name] = table_name
+          opts
+        end
+
+        def tfind_opts(opts)
+          opts = opts.dup
+          key = opts.delete(:key)
+          request_key = {}
+          @keys.keys.each_value do |attr_sym|
+            unless key[attr_sym]
+              raise Errors::KeyMissing.new(
+                "Missing required key #{attr_sym} in #{key}"
+              )
+            end
+            attr_name = attributes.storage_name_for(attr_sym)
+            request_key[attr_name] = attributes.attribute_for(attr_sym).
+              serialize(key[attr_sym])
+          end
+          # this is a :get item used by #transact_get_items, with the exception
+          # of :model_class which needs to be removed before passing along
+          opts[:key] = request_key
+          opts[:table_name] = table_name
+          {
+            model_class: self,
+            get: opts
+          }
+        end
+
+        # @example Usage Example
+        #   class Table
+        #     include Aws::Record
+        #     string_attr :hk, hash_key: true
+        #     string_attr :rk, range_key: true
+        #   end
+        #   
+        #   results = Table.transact_find(
+        #     transact_items: [
+        #       {key: { hk: "hk1", rk: "rk1"}},
+        #       {key: { hk: "hk2", rk: "rk2"}}
+        #     ]
+        #   ) # => results.responses contains nil or instances of Table
+        #
+        # Provides a way to run a transactional find across multiple DynamoDB
+        # items, including transactions which get items across multiple actual
+        # or virtual tables.
+        #
+        # @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
+        #   +#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 options describing
+        #   instances of the model class to return.
+        # @return [OpenStruct] Structured like the client API response from
+        #   +#transact_get_items+, except that the +responses+ member contains
+        #   +Aws::Record+ items marshaled into the model class used to call
+        #   this method. See the usage example.
+        def transact_find(opts)
+          opts = opts.dup
+          transact_items = opts.delete(:transact_items)
+          global_transact_items = transact_items.map do |topts|
+            tfind_opts(topts)
+          end
+          opts[:transact_items] = global_transact_items
+          opts[:client] = dynamodb_client
+          Transactions.transact_find(opts)
+        end
+
         # @example Usage Example
         #   class MyModel
         #     include Aws::Record

data/lib/aws-record/record/marshalers/epoch_time_marshaler.rb

@@ -55,6 +55,8 @@ module Aws
             raw_value
           when Integer # timestamp
             ::Time.at(raw_value)
+          when BigDecimal
+            ::Time.at(raw_value)
           else # Date, DateTime, or String
             ::Time.parse(raw_value.to_s)
           end

data/lib/aws-record/record/marshalers/numeric_set_marshaler.rb

@@ -58,7 +58,7 @@ module Aws
             if item.is_a?(Numeric)
               item
             else
-              BigDecimal.new(item.to_s)
+              BigDecimal(item.to_s)
             end
           end
         end

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

@@ -102,6 +102,54 @@ module Aws
           scan_opts = opts.merge(table_name: table_name)
           ItemCollection.new(:scan, scan_opts, self, dynamodb_client)
         end
+
+        # This method allows you to build a query using the {Aws::Record::BuildableSearch} DSL.
+        #
+        # @example Building a simple query:
+        #   # Example model class
+        #   class ExampleTable
+        #     include Aws::Record
+        #     string_attr  :uuid, hash_key: true
+        #     integer_attr :id,   range_key: true
+        #     string_attr  :body
+        #   end
+        #
+        #   q = ExampleTable.build_query.key_expr(
+        #         ":uuid = ? AND :id > ?", "smpl-uuid", 100
+        #       ).scan_ascending(false).complete!
+        #   q.to_a # You can use this like any other query result in aws-record
+        def build_query
+          BuildableSearch.new(
+            operation: :query,
+            model: self
+          )
+        end
+
+        # This method allows you to build a scan using the {Aws::Record::BuildableSearch} DSL.
+        #
+        # @example Building a simple scan:
+        #   # Example model class
+        #   class ExampleTable
+        #     include Aws::Record
+        #     string_attr  :uuid, hash_key: true
+        #     integer_attr :id,   range_key: true
+        #     string_attr  :body
+        #   end
+        #
+        #   segment_2_scan = ExampleTable.build_scan.filter_expr(
+        #     "contains(:body, ?)",
+        #     "bacon"
+        #   ).scan_ascending(false).parallel_scan(
+        #     total_segments: 5,
+        #     segment: 2
+        #   ).complete!
+        #   segment_2_scan.to_a # You can use this like any other query result in aws-record
+        def build_scan
+          BuildableSearch.new(
+            operation: :scan,
+            model: self
+          )
+        end
       end
 
     end

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

@@ -33,6 +33,17 @@ module Aws
     #     t.write_capacity_units 5
     #   end
     #
+    # @example A basic model with pay per request billing.
+    #   class Model
+    #     include Aws::Record
+    #     string_attr :uuid, hash_key: true
+    #   end
+    #
+    #   table_config = Aws::Record::TableConfig.define do |t|
+    #     t.model_class Model
+    #     t.billing_mode "PAY_PER_REQUEST"
+    #   end
+    #
     # @example Running a conditional migration on a basic model.
     #   table_config = Aws::Record::TableConfig.define do |t|
     #     t.model_class Model
@@ -59,7 +70,9 @@ module Aws
     #       :title,
     #       hash_key:  :forum_uuid,
     #       range_key: :post_title,
-    #       projection_type: "ALL"
+    #       projection: {
+    #         projection_type: "ALL"
+    #       }
     #     )
     #   end
     #
@@ -74,18 +87,18 @@ module Aws
     #     end
     #   end
     #
-    #  @example A model with a Time to Live attribute
-    #    class ExpiringTokens
-    #      string_attr :token_uuid, hash_key: true
-    #      epoch_time_attr :ttl
-    #    end
+    # @example A model with a Time to Live attribute
+    #   class ExpiringTokens
+    #     string_attr :token_uuid, hash_key: true
+    #     epoch_time_attr :ttl
+    #   end
     #
-    #    table_config = Aws::Record::TableConfig.define do |t|
-    #      t.model_class ExpiringTokens
-    #      t.read_capacity_units 10
-    #      t.write_capacity_units 1
-    #      t.ttl_attribute :ttl
-    #    end
+    #   table_config = Aws::Record::TableConfig.define do |t|
+    #     t.model_class ExpiringTokens
+    #     t.read_capacity_units 10
+    #     t.write_capacity_units 1
+    #     t.ttl_attribute :ttl
+    #   end
     #
     class TableConfig
 
@@ -106,7 +119,12 @@ module Aws
         #   * +#write_capacity_units+ Sets the write capacity units for the
         #     index.
         # * +#ttl_attribute+ Sets the attribute ID to be used as the TTL
-        #     attribute, and if present, TTL will be enabled for the table.
+        #   attribute, and if present, TTL will be enabled for the table.
+        # * +#billing_mode+ Sets the billing mode, with the current supported
+        #   options being "PROVISIONED" and "PAY_PER_REQUEST". If using
+        #   "PAY_PER_REQUEST" you must not set provisioned throughput values,
+        #   and if using "PROVISIONED" you must set provisioned throughput
+        #   values. Default assumption is "PROVISIONED".
         #
         # @example Defining a migration with a GSI.
         #   class Forum
@@ -151,6 +169,7 @@ module Aws
       def initialize
         @client_options = {}
         @global_secondary_indexes = {}
+        @billing_mode = "PROVISIONED" # default
       end
 
       # @api private
@@ -195,6 +214,11 @@ module Aws
         end
       end
 
+      # @api private
+      def billing_mode(mode)
+        @billing_mode = mode
+      end
+
       # Performs a migration, if needed, against the remote table. If
       # +#compatible?+ would return true, the remote table already has the same
       # throughput, key schema, attribute definitions, and global secondary
@@ -209,13 +233,7 @@ module Aws
           else
             # Gotcha: You need separate migrations for indexes and throughput
             unless _throughput_equal(resp)
-              @client.update_table(
-                table_name: @model_class.table_name,
-                provisioned_throughput: {
-                  read_capacity_units: @read_capacity_units,
-                  write_capacity_units: @write_capacity_units
-                }
-              )
+              @client.update_table(_update_throughput_opts(resp))
               @client.wait_until(
                 :table_exists,
                 table_name: @model_class.table_name
@@ -327,12 +345,19 @@ module Aws
 
       def _create_table_opts
         opts = {
-          table_name: @model_class.table_name,
-          provisioned_throughput: {
+          table_name: @model_class.table_name
+        }
+        if @billing_mode == "PROVISIONED"
+          opts[:provisioned_throughput] = {
             read_capacity_units: @read_capacity_units,
             write_capacity_units: @write_capacity_units
           }
-        }
+        elsif @billing_mode == "PAY_PER_REQUEST"
+          opts[:billing_mode] = @billing_mode
+        else
+          raise ArgumentError, "Unsupported billing mode #{@billing_mode}"
+        end
+          
         opts[:key_schema] = _key_schema
         opts[:attribute_definitions] = _attribute_definitions
         gsi = _global_secondary_indexes
@@ -342,6 +367,54 @@ module Aws
         opts
       end
 
+      def _add_global_secondary_index_throughput(opts, resp_gsis)
+        gsis = resp_gsis.map do |g|
+          g.index_name
+        end
+        gsi_updates = []
+        gsis.each do |index_name|
+          lgsi = @global_secondary_indexes[index_name.to_sym]
+          gsi_updates << {
+            update: {
+              index_name: index_name,
+              provisioned_throughput: lgsi.provisioned_throughput
+            }
+          }
+        end
+        opts[:global_secondary_index_updates] = gsi_updates
+        true
+      end
+
+      def _update_throughput_opts(resp)
+        if @billing_mode == "PROVISIONED"
+          opts = {
+            table_name: @model_class.table_name,
+            provisioned_throughput: {
+              read_capacity_units: @read_capacity_units,
+              write_capacity_units: @write_capacity_units
+            }
+          }
+          # special case: we have global secondary indexes existing, and they
+          # need provisioned capacity to be set within this call
+          if !resp.table.billing_mode_summary.nil? &&
+              resp.table.billing_mode_summary.billing_mode == "PAY_PER_REQUEST"
+            opts[:billing_mode] = @billing_mode
+            if resp.table.global_secondary_indexes
+              resp_gsis = resp.table.global_secondary_indexes
+              _add_global_secondary_index_throughput(opts, resp_gsis)
+            end
+          end # else don't include billing mode
+          opts
+        elsif @billing_mode == "PAY_PER_REQUEST"
+          {
+            table_name: @model_class.table_name,
+            billing_mode: "PAY_PER_REQUEST"
+          }
+        else
+          raise ArgumentError, "Unsupported billing mode #{@billing_mode}"
+        end
+      end
+
       def _update_index_opts(resp)
         gsi_updates, attribute_definitions = _gsi_updates(resp)
         opts = {
@@ -369,22 +442,25 @@ module Aws
           gsi[:key_schema].each do |k|
             attributes_referenced.add(k[:attribute_name])
           end
-          # This may be a problem, check if I can maintain symbols.
-          lgsi = @global_secondary_indexes[index_name.to_sym]
-          gsi[:provisioned_throughput] = lgsi.provisioned_throughput
+          if @billing_mode == "PROVISIONED"
+            lgsi = @global_secondary_indexes[index_name.to_sym]
+            gsi[:provisioned_throughput] = lgsi.provisioned_throughput
+          end
           gsi_updates << {
             create: gsi
           }
         end
-        update_candidates.each do |index_name|
-          # This may be a problem, check if I can maintain symbols.
-          lgsi = @global_secondary_indexes[index_name.to_sym]
-          gsi_updates << {
-            update: {
-              index_name: index_name,
-              provisioned_throughput: lgsi.provisioned_throughput
+        # we don't currently update anything other than throughput
+        if @billing_mode == "PROVISIONED"
+          update_candidates.each do |index_name|
+            lgsi = @global_secondary_indexes[index_name.to_sym]
+            gsi_updates << {
+              update: {
+                index_name: index_name,
+                provisioned_throughput: lgsi.provisioned_throughput
+              }
             }
-          }
+          end
         end
         attribute_definitions = _attribute_definitions
         incremental_attributes = attributes_referenced.map do |attr_name|
@@ -438,13 +514,18 @@ module Aws
       end
 
       def _throughput_equal(resp)
-        expected = resp.table.provisioned_throughput.to_h
-        actual = {
-          read_capacity_units: @read_capacity_units,
-          write_capacity_units: @write_capacity_units
-        }
-        actual.all? do |k,v|
-          expected[k] == v
+        if @billing_mode == "PAY_PER_REQUEST"
+          !resp.table.billing_mode_summary.nil? &&
+            resp.table.billing_mode_summary.billing_mode == "PAY_PER_REQUEST"
+        else
+          expected = resp.table.provisioned_throughput.to_h
+          actual = {
+            read_capacity_units: @read_capacity_units,
+            write_capacity_units: @write_capacity_units
+          }
+          actual.all? do |k,v|
+            expected[k] == v
+          end
         end
       end
 
@@ -498,10 +579,17 @@ module Aws
           remote_key_schema = rgsi.key_schema.map { |i| i.to_h }
           ks_match = _array_unsorted_eql(remote_key_schema, lgsi[:key_schema])
 
+          # Throughput Check: Dependent on Billing Mode
           rpt = rgsi.provisioned_throughput.to_h
           lpt = lgsi[:provisioned_throughput]
-          pt_match = lpt.all? do |k,v|
-            rpt[k] == v
+          if @billing_mode == "PROVISIONED"
+            pt_match = lpt.all? do |k,v|
+              rpt[k] == v
+            end
+          elsif @billing_mode == "PAY_PER_REQUEST"
+            pt_match = lpt.nil? ? true : false
+          else
+            raise ArgumentError, "Unsupported billing mode #{@billing_mode}"
           end
 
           rp = rgsi.projection.to_h
@@ -537,10 +625,13 @@ module Aws
         if model_gsis
           model_gsis.each do |mgsi|
             config = gsi_config[mgsi[:index_name]]
-            # Validate throughput exists? Validate each throughput is in model?
-            gsis << mgsi.merge(
-              provisioned_throughput: config.provisioned_throughput
-            )
+            if @billing_mode == "PROVISIONED"
+              gsis << mgsi.merge(
+                provisioned_throughput: config.provisioned_throughput
+              )
+            else
+              gsis << mgsi
+            end
           end
         end
         gsis
@@ -553,8 +644,14 @@ module Aws
       def _validate_required_configuration
         missing_config = []
         missing_config << 'model_class' unless @model_class
-        missing_config << 'read_capacity_units' unless @read_capacity_units
-        missing_config << 'write_capacity_units' unless @write_capacity_units
+        if @billing_mode == "PROVISIONED"
+          missing_config << 'read_capacity_units' unless @read_capacity_units
+          missing_config << 'write_capacity_units' unless @write_capacity_units
+        else
+          if @read_capacity_units || @write_capacity_units
+            raise ArgumentError.new("Cannot have billing mode #{@billing_mode} with provisioned capacity.")
+          end
+        end
         unless missing_config.empty?
           msg = missing_config.join(', ')
           raise Errors::MissingRequiredConfiguration, 'Missing: ' + msg

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

@@ -0,0 +1,332 @@
+module Aws
+  module Record
+    module Transactions
+      class << self
+
+        # @example Usage Example
+        #   class TableOne
+        #     include Aws::Record
+        #     string_attr :uuid, hash_key: true
+        #   end
+        #   
+        #   class TableTwo
+        #     include Aws::Record
+        #     string_attr :hk, hash_key: true
+        #     string_attr :rk, range_key: true
+        #   end
+        #   
+        #   results = Aws::Record::Transactions.transact_find(
+        #     transact_items: [
+        #       TableOne.tfind_opts(key: { uuid: "uuid1234" }),
+        #       TableTwo.tfind_opts(key: { hk: "hk1", rk: "rk1"}),
+        #       TableTwo.tfind_opts(key: { hk: "hk2", rk: "rk2"})
+        #     ]
+        #   ) # => results.responses contains nil or marshalled items
+        #   results.responses.map { |r| r.class } # [TableOne, TableTwo, TableTwo]
+        #
+        # Provides a way to run a transactional find across multiple DynamoDB
+        # items, including transactions which get items across multiple actual
+        # or virtual tables.
+        #
+        # @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
+        #   +#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
+        #   in your own client to use for the transaction calls.
+        # @return [OpenStruct] Structured like the client API response from
+        #   +#transact_get_items+, except that the +responses+ member contains
+        #   +Aws::Record+ items marshaled into the classes used to call
+        #   +#tfind_opts+ in each positional member. See the usage example.
+        def transact_find(opts)
+          opts = opts.dup
+          client = opts.delete(:client) || dynamodb_client
+          transact_items = opts.delete(:transact_items) # add nil check?
+          model_classes = []
+          client_transact_items = transact_items.map do |tfind_opts|
+            model_class = tfind_opts.delete(:model_class)
+            model_classes << model_class
+            tfind_opts
+          end
+          request_opts = opts
+          request_opts[:transact_items] = client_transact_items
+          client_resp = client.transact_get_items(
+            request_opts
+          )
+          responses = client_resp.responses
+          index = -1
+          ret = OpenStruct.new
+          ret.consumed_capacity = client_resp.consumed_capacity
+          ret.missing_items = []
+          ret.responses = client_resp.responses.map do |item|
+            index += 1
+            if item.nil? || item.item.nil?
+              missing_data = {
+                model_class: model_classes[index],
+                key: transact_items[index][:get][:key]
+              }
+              ret.missing_items << missing_data
+              nil
+            else
+              # need to translate the item keys
+              raw_item = item.item
+              model_class = model_classes[index]
+              new_item_opts = {}
+              raw_item.each do |db_name, value|
+                name = model_class.attributes.db_to_attribute_name(db_name)
+                new_item_opts[name] = value
+              end
+              item = model_class.new(new_item_opts)
+              item.clean!
+              item
+            end
+          end
+          ret
+        end
+
+        # @example Usage Example
+        #   class TableOne
+        #     include Aws::Record
+        #     string_attr :uuid, hash_key: true
+        #     string_attr :body
+        #   end
+        #   
+        #   class TableTwo
+        #     include Aws::Record
+        #     string_attr :hk, hash_key: true
+        #     string_attr :rk, range_key: true
+        #     string_attr :body
+        #   end
+        #   
+        #   check_exp = TableOne.transact_check_expression(
+        #     key: { uuid: "foo" },
+        #     condition_expression: "size(#T) <= :v",
+        #     expression_attribute_names: {
+        #       "#T" => "body"
+        #     },
+        #     expression_attribute_values: {
+        #       ":v" => 1024
+        #     }
+        #   )
+        #   new_item = TableTwo.new(hk: "hk1", rk: "rk1", body: "Hello!")
+        #   update_item_1 = TableOne.find(uuid: "bar")
+        #   update_item_1.body = "Updated the body!"
+        #   put_item = TableOne.new(uuid: "foobar", body: "Content!")
+        #   update_item_2 = TableTwo.find(hk: "hk2", rk: "rk2")
+        #   update_item_2.body = "Update!"
+        #   delete_item = TableOne.find(uuid: "to_be_deleted")
+        #   
+        #   Aws::Record::Transactions.transact_write(
+        #     transact_items: [
+        #       { check: check_exp },
+        #       { save: new_item },
+        #       { save: update_item_1 },
+        #       {
+        #          put: put_item,
+        #          condition_expression: "attribute_not_exists(#H)",
+        #          expression_attribute_names: { "#H" => "uuid" },
+        #          return_values_on_condition_check_failure: "ALL_OLD"
+        #       },
+        #       { update: update_item_2 },
+        #       { delete: delete_item }
+        #     ]
+        #   )
+        #
+        # Provides a way to pass in aws-record items into transactional writes,
+        # as well as adding the ability to run 'save' commands in a transaction
+        # while allowing aws-record to determine if a :put or :update operation
+        # is most appropriate. +#transact_write+ supports 5 different transact
+        # item modes:
+        # - save: Behaves much like the +#save+ operation on the item itself.
+        #   If the keys are dirty, and thus it appears to be a new item, will
+        #   create a :put operation with a conditional check on the item's
+        #   existance. Note that you cannot bring your own conditional
+        #   expression in this case. If you wish to force put or add your
+        #   own conditional checks, use the :put operation.
+        # - put: Does a force put for the given item key and model.
+        # - update: Does an upsert for the given item.
+        # - delete: Deletes the given item.
+        # - check: Takes the result of +#transact_check_expression+,
+        #   performing the specified check as a part of the transaction.
+        #
+        # @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.
+        # @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
+        #   specify a client to use for this transaction call. If not
+        #   specified, the configured client for +Aws::Record::Transactions+
+        #   is used.
+        def transact_write(opts)
+          opts = opts.dup
+          client = opts.delete(:client) || dynamodb_client
+          dirty_items = []
+          delete_items = []
+          # fetch abstraction records
+          transact_items = _transform_transact_write_items(
+            opts.delete(:transact_items),
+            dirty_items,
+            delete_items
+          )
+          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 }
+          resp
+        end
+
+        # Configures the Amazon DynamoDB client used by global transaction
+        # operations.
+        #
+        # Please note that this method is also called internally when you first
+        # attempt to perform an operation against the remote end, if you have
+        # not already configured a client. As such, please read and understand
+        # the documentation in the AWS SDK for Ruby V3 around
+        # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/#Configuration configuration}
+        # to ensure you understand how default configuration behavior works.
+        # When in doubt, call this method to ensure your client is configured
+        # the way you want it to be configured.
+        #
+        # @param [Hash] opts the options you wish to use to create the client.
+        #  Note that if you include the option +:client+, all other options
+        #  will be ignored. See the documentation for other options in the
+        #  {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#initialize-instance_method AWS SDK for Ruby V3}.
+        # @option opts [Aws::DynamoDB::Client] :client allows you to pass in
+        #  your own pre-configured client.
+        def configure_client(opts = {})
+          provided_client = opts.delete(:client)
+          opts[:user_agent_suffix] = _user_agent(
+            opts.delete(:user_agent_suffix)
+          )
+          client = provided_client || Aws::DynamoDB::Client.new(opts)
+          @@dynamodb_client = client
+        end
+
+        # Gets the
+        # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html}
+        # instance that Transactions use. When called for the first time, if
+        # {#configure_client} has not yet been called, will configure a new
+        # client for you with default parameters.
+      #
+      # @return [Aws::DynamoDB::Client] the Amazon DynamoDB client instance.
+        def dynamodb_client
+          @@dynamodb_client ||= configure_client
+        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)
+              dirty_items << save_record
+              _transform_save_record(save_record, item)
+            elsif put_record = item.delete(:put)
+              dirty_items << put_record
+              _transform_put_record(put_record, item)
+            elsif delete_record = item.delete(:delete)
+              delete_items << delete_record
+              _transform_delete_record(delete_record, item)
+            elsif update_record = item.delete(:update)
+              dirty_items << update_record
+              _transform_update_record(update_record, item)
+            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}"
+              )
+            end
+          end
+        end
+
+        def _transform_save_record(save_record, opts)
+          # determine if record is considered a new item or not
+          # then create a put with conditions, or an update
+          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)}"
+              )
+            else
+              opts = opts.merge(safety_expression)
+              _transform_put_record(save_record, opts)
+            end
+          else
+            _transform_update_record(save_record, opts)
+          end
+        end
+
+        def _transform_put_record(put_record, opts)
+          # convert to a straight put
+          opts[:table_name] = put_record.class.table_name
+          opts[:item] = put_record.send(:_build_item_for_save)
+          { put: opts }
+        end
+
+        def _transform_delete_record(delete_record, opts)
+          # extract the key from each record to perform a deletion
+          opts[:table_name] = delete_record.class.table_name
+          opts[:key] = delete_record.send(:key_values)
+          { delete: opts }
+        end
+
+        def _transform_update_record(update_record, opts)
+          # extract dirty attribute changes to perform an update
+          opts[:table_name] = update_record.class.table_name
+          dirty_changes = update_record.send(:_dirty_changes_for_update)
+          update_tuple = update_record.class.send(
+            :_build_update_expression,
+            dirty_changes
+          )
+          uex, exp_attr_names, exp_attr_values = update_tuple
+          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
+          { update: opts }
+        end
+
+        def _transform_check_record(check_record, opts)
+          # check records are a pass-through
+          { condition_check: opts.merge(check_record) }
+        end
+
+        def _user_agent(custom)
+          if custom
+            custom
+          else
+            " aws-record/#{VERSION}"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -13,6 +13,6 @@
 
 module Aws
   module Record
-    VERSION = '2.1.1'
+    VERSION = '2.4.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-record
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.4.1
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2020-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.18'
 description: Provides an object mapping abstraction for Amazon DynamoDB.
 email:
 - alexwood@amazon.com
@@ -35,6 +35,7 @@ files:
 - lib/aws-record/record.rb
 - lib/aws-record/record/attribute.rb
 - lib/aws-record/record/attributes.rb
+- lib/aws-record/record/buildable_search.rb
 - lib/aws-record/record/dirty_tracking.rb
 - lib/aws-record/record/errors.rb
 - lib/aws-record/record/item_collection.rb
@@ -58,6 +59,7 @@ files:
 - lib/aws-record/record/secondary_indexes.rb
 - lib/aws-record/record/table_config.rb
 - lib/aws-record/record/table_migration.rb
+- lib/aws-record/record/transactions.rb
 - lib/aws-record/record/version.rb
 homepage: http://github.com/aws/aws-sdk-ruby-record
 licenses:
@@ -78,8 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: AWS Record library for Amazon DynamoDB