aws-record 2.7.0 → 2.10.1

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

@@ -1,15 +1,4 @@
-# Copyright 2015-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You may not
-# use this file except in compliance with the License. A copy of the License is
-# located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is distributed on
-# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
-# or implied. See the License for the specific language governing permissions
-# and limitations under the License.
+# frozen_string_literal: true
 
 module Aws
   module Record
@@ -20,8 +9,20 @@ module Aws
         model_attributes = ModelAttributes.new(self)
         sub_class.instance_variable_set("@attributes", model_attributes)
         sub_class.instance_variable_set("@keys", KeyAttributes.new(model_attributes))
+        if Aws::Record.extends_record?(sub_class)
+          inherit_attributes(sub_class)
+        end
       end
 
+      # Base initialization method for a new item. Optionally, allows you to
+      # provide initial attribute values for the model. You do not need to
+      # provide all, or even any, attributes at item creation time.
+      #
+      # === Inheritance Support
+      # Child models will inherit the attributes and keys defined in the parent
+      # model. Child models can override attribute keys if defined in their own model.
+      #
+      # See examples below to see the feature in action.
       # @example Usage Example
       #   class MyModel
       #     include Aws::Record
@@ -31,11 +32,34 @@ module Aws
       #   end
       #
       #   item = MyModel.new(id: 1, name: "Quick Create")
+      # @example Child model inheriting from Parent model
+      #   class Animal
+      #     include Aws::Record
+      #     string_attr :name,   hash_key: true
+      #     integer_attr :age,   default_value: 1
+      #   end
       #
-      # Base initialization method for a new item. Optionally, allows you to
-      # provide initial attribute values for the model. You do not need to
-      # provide all, or even any, attributes at item creation time.
+      #   class Cat < Animal
+      #     include Aws::Record
+      #     integer_attr :num_of_wiskers
+      #   end
       #
+      #   cat = Cat.find(name: 'Foo')
+      #   cat.age    # => 1
+      #   cat.num_of_wiskers = 200
+      # @example Child model overrides the hash key
+      #   class Animal
+      #     include Aws::Record
+      #     string_attr :name,   hash_key: true
+      #     integer_attr :age,   range_key: true
+      #   end
+      #
+      #   class Dog < Animal
+      #     include Aws::Record
+      #     integer_attr :id, hash_key: true
+      #   end
+      #
+      #   Dog.keys # => {:hash=>:id, :range=>:age}
       # @param [Hash] attr_values Attribute symbol/value pairs for any initial
       #  attribute values you wish to set.
       # @return [Aws::Record] An item instance for your model.
@@ -56,6 +80,27 @@ module Aws
         @data.hash_copy
       end
 
+      private
+      def self.inherit_attributes(klass)
+        superclass_attributes = klass.superclass.instance_variable_get("@attributes")
+
+        superclass_attributes.attributes.each do |name, attribute|
+          subclass_attributes = klass.instance_variable_get("@attributes")
+          subclass_attributes.register_superclass_attribute(name, attribute)
+        end
+
+        superclass_keys = klass.superclass.instance_variable_get("@keys")
+        subclass_keys = klass.instance_variable_get("@keys")
+
+        if superclass_keys.hash_key
+          subclass_keys.hash_key = superclass_keys.hash_key
+        end
+
+        if superclass_keys.range_key
+          subclass_keys.range_key = superclass_keys.range_key
+        end
+      end
+
       module ClassMethods
 
         # Define an attribute for your model, providing your own attribute type.
@@ -82,7 +127,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         # @option opts [Boolean] :hash_key Set to true if this attribute is
         #   the hash key for the table.
         # @option opts [Boolean] :range_key Set to true if this attribute is
@@ -108,7 +154,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def string_attr(name, opts = {})
           opts[:dynamodb_type] = "S"
           attr(name, Marshalers::StringMarshaler.new(opts), opts)
@@ -129,7 +176,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def boolean_attr(name, opts = {})
           opts[:dynamodb_type] = "BOOL"
           attr(name, Marshalers::BooleanMarshaler.new(opts), opts)
@@ -150,7 +198,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def integer_attr(name, opts = {})
           opts[:dynamodb_type] = "N"
           attr(name, Marshalers::IntegerMarshaler.new(opts), opts)
@@ -171,7 +220,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def float_attr(name, opts = {})
           opts[:dynamodb_type] = "N"
           attr(name, Marshalers::FloatMarshaler.new(opts), opts)
@@ -192,7 +242,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option options [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def date_attr(name, opts = {})
           opts[:dynamodb_type] = "S"
           attr(name, Marshalers::DateMarshaler.new(opts), opts)
@@ -213,7 +264,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def datetime_attr(name, opts = {})
           opts[:dynamodb_type] = "S"
           attr(name, Marshalers::DateTimeMarshaler.new(opts), opts)
@@ -234,14 +286,15 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def time_attr(name, opts = {})
           opts[:dynamodb_type] = "S"
           attr(name, Marshalers::TimeMarshaler.new(opts), opts)
         end
 
         # Define a time-type attribute for your model which persists as
-        #   epoch-seconds.
+        # epoch-seconds.
         #
         # @param [Symbol] name Name of this attribute.  It should be a name
         #   that is safe to use as a method.
@@ -256,7 +309,8 @@ module Aws
         #   nil values will be ignored and not persisted. By default, is false.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def epoch_time_attr(name, opts = {})
           opts[:dynamodb_type] = "N"
           attr(name, Marshalers::EpochTimeMarshaler.new(opts), opts)
@@ -265,7 +319,7 @@ module Aws
         # Define a list-type attribute for your model.
         #
         # Lists do not have to be homogeneous, but they do have to be types that
-        # the AWS SDK for Ruby V2's DynamoDB client knows how to marshal and
+        # the AWS SDK for Ruby V3's DynamoDB client knows how to marshal and
         # unmarshal. Those types are:
         #
         # * Hash
@@ -291,7 +345,8 @@ module Aws
         #   the range key for the table.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def list_attr(name, opts = {})
           opts[:dynamodb_type] = "L"
           attr(name, Marshalers::ListMarshaler.new(opts), opts)
@@ -300,7 +355,7 @@ module Aws
         # Define a map-type attribute for your model.
         #
         # Maps do not have to be homogeneous, but they do have to use types that
-        # the AWS SDK for Ruby V2's DynamoDB client knows how to marshal and
+        # the AWS SDK for Ruby V3's DynamoDB client knows how to marshal and
         # unmarshal. Those types are:
         #
         # * Hash
@@ -326,7 +381,8 @@ module Aws
         #   the range key for the table.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def map_attr(name, opts = {})
           opts[:dynamodb_type] = "M"
           attr(name, Marshalers::MapMarshaler.new(opts), opts)
@@ -351,7 +407,8 @@ module Aws
         #   the range key for the table.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time. Additionally, lambda
+        #   can be used as a default value.
         def string_set_attr(name, opts = {})
           opts[:dynamodb_type] = "SS"
           attr(name, Marshalers::StringSetMarshaler.new(opts), opts)
@@ -376,18 +433,90 @@ module Aws
         #   the range key for the table.
         # @option opts [Object] :default_value Optional attribute used to
         #   define a "default value" to be used if the attribute's value on an
-        #   item is nil or not set at persistence time.
+        #   item is nil or not set at persistence time.  Additionally, lambda
+        #   can be used as a default value.
         def numeric_set_attr(name, opts = {})
           opts[:dynamodb_type] = "NS"
           attr(name, Marshalers::NumericSetMarshaler.new(opts), opts)
         end
 
+        # Define an atomic counter attribute for your model.
+        #
+        # Atomic counter are an integer-type attribute that is incremented,
+        # unconditionally, without interfering with other write requests.
+        # The numeric value increments each time you call +increment_<attr>!+.
+        # If a specific numeric value are passed in the call, the attribute will
+        # increment by that value.
+        #
+        # To use +increment_<attr>!+ method, the following condition must be true:
+        # * None of the attributes have dirty changes.
+        # * If there is a value passed in, it must be an integer.
+        # For more information, see
+        # {https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.AtomicCounters Atomic counter}
+        # in the Amazon DynamoDB Developer Guide.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] opts
+        # @option opts [Object] :default_value Optional attribute used to
+        #   define a "default value" to be used if the attribute's value on an
+        #   item is nil or not set at persistence time. The "default value" of
+        #   the attribute starts at 0.
+        #
+        # @example Usage Example
+        #   class MyRecord
+        #     include Aws::Record
+        #     integer_attr :id, hash_key: true
+        #     atomic_counter :counter
+        #   end
+        #
+        #   record = MyRecord.find(id: 1)
+        #   record.counter #=> 0
+        #   record.increment_counter! #=> 1
+        #   record.increment_counter!(2) #=> 3
+        # @see #attr #attr method for additional hash options.
+        def atomic_counter(name, opts = {})
+          opts[:dynamodb_type] = "N"
+          opts[:default_value] ||= 0
+          attr(name, Marshalers::IntegerMarshaler.new(opts), opts)
+
+          define_method("increment_#{name}!") do |increment=1|
+
+            if dirty?
+              msg = "Attributes need to be saved before atomic counter can be incremented"
+              raise Errors::RecordError, msg
+            end
+
+            unless increment.is_a?(Integer)
+              msg = "expected an Integer value, got #{increment.class}"
+              raise ArgumentError, msg
+            end
+
+            resp = dynamodb_client.update_item({
+              table_name: self.class.table_name,
+              key: key_values,
+              expression_attribute_values: {
+                ":i" => increment
+              },
+              expression_attribute_names: {
+                "#n" => name
+              },
+              update_expression: "SET #n = #n + :i",
+              return_values: "UPDATED_NEW"
+            })
+            assign_attributes(resp[:attributes])
+            @data.clean!
+            @data.get_attribute(name)
+          end
+
+        end
+
         # @return [Symbol,nil] The symbolic name of the table's hash key.
         def hash_key
           @keys.hash_key
         end
 
-        # @return [Symbol,nil] The symbloc name of the table's range key, or nil if there is no range key.
+        # @return [Symbol,nil] The symbolic name of the table's range key, or nil if there is no range key.
         def range_key
           @keys.range_key
         end

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

@@ -1,15 +1,4 @@
-# Copyright 2015-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You may not
-# use this file except in compliance with the License. A copy of the License is
-# located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is distributed on
-# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
-# or implied. See the License for the specific language governing permissions
-# and limitations under the License.
+# frozen_string_literal: true
 
 module Aws
   module Record
@@ -17,6 +6,28 @@ module Aws
       extend ClientConfiguration
 
       class << self
+        # Provides a thin wrapper to the
+        # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#batch_write_item-instance_method Aws::DynamoDB::Client#batch_write_item}
+        # method. Up to 25 +PutItem+ or +DeleteItem+ operations are supported.
+        # A single request may write up to 16 MB of data, with each item having a
+        # write limit of 400 KB.
+        #
+        # *Note*: this operation does not support dirty attribute handling,
+        # nor does it enforce safe write operations (i.e. update vs new record
+        # checks).
+        #
+        # This call may partially execute write operations. Failed operations
+        # are returned as {BatchWrite.unprocessed_items unprocessed_items} (i.e. the
+        # table fails to meet requested write capacity). Any unprocessed
+        # items may be retried by calling {BatchWrite.execute! .execute!}
+        # again. You can determine if the request needs to be retried by calling
+        # the {BatchWrite.complete? .complete?} method - which returns +true+
+        # when all operations have been completed.
+        #
+        # Please see
+        # {https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html#Programming.Errors.BatchOperations Batch Operations and Error Handling}
+        # in the DynamoDB Developer Guide for more details.
+        #
         # @example Usage Example
         #   class Breakfast
         #     include Aws::Record
@@ -38,29 +49,7 @@ module Aws
         #   end
         #
         #   # unprocessed items can be retried by calling Aws::Record::BatchWrite#execute!
-        #   operation.execute! unless operation.complete?
-        #
-        # Provides a thin wrapper to the
-        # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#batch_write_item-instance_method Aws::DynamoDB::Client#batch_write_item}
-        # method. Up to 25 +PutItem+ or +DeleteItem+ operations are supported.
-        # A single rquest may write up to 16 MB of data, with each item having a
-        # write limit of 400 KB.
-        #
-        # *Note*: this operation does not support dirty attribute handling,
-        # nor does it enforce safe write operations (i.e. update vs new record
-        # checks).
-        #
-        # This call may partially execute write operations. Failed operations
-        # are returned as +Aws::Record::BatchWrite#unprocessed_items+ (i.e. the
-        # table fails to meet requested write capacity). Any unprocessed
-        # items may be retried by calling +Aws::Record::BatchWrite#execute!+
-        # again. You can determine if the request needs to be retried by calling
-        # the +Aws::Record::BatchWrite#complete?+ method - which returns +true+
-        # when all operations have been completed.
-        #
-        # Please see
-        # {https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html#Programming.Errors.BatchOperations Batch Operations and Error Handling}
-        # in the DynamoDB Developer Guide for more details.
+        #   operation.execute! until operation.complete?
         #
         # @param [Hash] opts the options you wish to use to create the client.
         #  Note that if you include the option +:client+, all other options
@@ -76,6 +65,81 @@ module Aws
           block.call(batch)
           batch.execute!
         end
+
+        # Provides support for the
+        # {https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#batch_get_item-instance_method
+        # Aws::DynamoDB::Client#batch_get_item} for aws-record models.
+        #
+        # +Aws::Record::Batch+ is Enumerable and using Enumerable methods will handle
+        # paging through all requested keys automatically. Alternatively, a lower level
+        # interface is available. You can determine if there are any unprocessed keys by calling
+        # {BatchRead.complete? .complete?} and any unprocessed keys can be processed by
+        # calling {BatchRead.execute! .execute!}. You can access all processed items
+        # through {BatchRead.items .items}.
+        #
+        # The +batch_get_item+ supports up to 100 operations in a single call and a single
+        # operation can retrieve up to 16 MB of data.
+        #
+        # +Aws::Record::BatchRead+ can take more than 100 item keys. The first 100 requests
+        # will be processed and the remaining requests will be stored.
+        # When using Enumerable methods, any pending item keys will be automatically
+        # processed and the new items will be added to +items+.
+        # Alternately, use {BatchRead.execute! .execute!} to process any pending item keys.
+        #
+        # All processed operations can be accessed by {BatchRead.items items} - which is an
+        # array of modeled items from the response. The items will be unordered since
+        # DynamoDB does not return items in any particular order.
+        #
+        # If a requested item does not exist in the database, it is not returned in the response.
+        #
+        # If there is a returned item from the call and there's no reference model class
+        # to be found, the item will not show up under +items+.
+        #
+        # @example Usage Example
+        #   class Lunch
+        #     include Aws::Record
+        #     integer_attr :id,   hash_key: true
+        #     string_attr  :name, range_key: true
+        #   end
+        #
+        #   class Dessert
+        #     include Aws::Record
+        #     integer_attr :id,   hash_key: true
+        #     string_attr  :name, range_key: true
+        #   end
+        #
+        #   # batch operations
+        #   operation = Aws::Record::Batch.read do |db|
+        #     db.find(Lunch, id: 1, name: 'Papaya Salad')
+        #     db.find(Lunch, id: 2, name: 'BLT Sandwich')
+        #     db.find(Dessert, id: 1, name: 'Apple Pie')
+        #   end
+        #
+        #   # BatchRead is enumerable and handles pagination
+        #   operation.each { |item| item.id }
+        #
+        #   # Alternatively, BatchRead provides a lower level
+        #   # interface through: execute!, complete? and items.
+        #   # Unprocessed items can be processed by calling:
+        #   operation.execute! until operation.complete?
+        #
+        # @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}.
+        # @option opts [Aws::DynamoDB::Client] :client allows you to pass in your
+        #  own pre-configured client.
+        # @return [Aws::Record::BatchRead] An instance that contains modeled items
+        #  from the +BatchGetItem+ result and stores unprocessed keys to be
+        #  manually processed later.
+        def read(opts = {}, &block)
+          batch = BatchRead.new(client: _build_client(opts))
+          block.call(batch)
+          batch.execute!
+          batch
+        end
+
       end
     end
   end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Aws
+  module Record
+    class BatchRead
+      include Enumerable
+
+      # @api private
+      BATCH_GET_ITEM_LIMIT = 100
+
+      # @param [Aws::DynamoDB::Client] client the DynamoDB SDK client.
+      def initialize(opts = {})
+        @client = opts[:client]
+      end
+
+      # Append the item keys to a batch read request.
+      #
+      # See {Batch.read} for example usage.
+      # @param [Aws::Record] klass a model class that includes {Aws::Record}
+      # @param [Hash] key attribute-value pairs for the key you wish to search for.
+      # @raise [Aws::Record::Errors::KeyMissing] if your option parameters
+      #  do not include all item keys defined in the model.
+      # @raise [ArgumentError] if the provided item keys is a duplicate request
+      #  in the same instance.
+      def find(klass, key = {})
+        unprocessed_key = format_unprocessed_key(klass, key)
+        store_unprocessed_key(klass, unprocessed_key)
+        store_item_class(klass, unprocessed_key)
+      end
+
+      # Perform a +batch_get_item+ request.
+      #
+      # This method processes the first 100 item keys and
+      # returns an array of new modeled items.
+      #
+      # See {Batch.read} for example usage.
+      # @return [Array] an array of unordered new items
+      def execute!
+        operation_keys = unprocessed_keys[0..BATCH_GET_ITEM_LIMIT - 1]
+        @unprocessed_keys = unprocessed_keys[BATCH_GET_ITEM_LIMIT..-1] || []
+
+        operations = build_operations(operation_keys)
+        result = @client.batch_get_item(request_items: operations)
+        new_items = build_items(result.responses)
+        items.concat(new_items)
+
+        unless result.unprocessed_keys.nil?
+          update_unprocessed_keys(result.unprocessed_keys)
+        end
+
+        new_items
+      end
+
+      # Provides an enumeration of the results from the +batch_get_item+ request
+      # and handles pagination.
+      #
+      # Any pending item keys will be automatically processed and be
+      # added to the {#items}.
+      #
+      # See {Batch.read} for example usage.
+      # @yieldparam [Aws::Record] item a modeled item
+      # @return [Enumerable<BatchRead>] an enumeration over the results of
+      #  +batch_get_item+ request.
+      def each
+        return enum_for(:each) unless block_given?
+
+        @items.each { |item| yield item }
+        until complete?
+          new_items = execute!
+          new_items.each { |new_item| yield new_item }
+        end
+      end
+
+      # Indicates if all item keys have been processed.
+      #
+      # See {Batch.read} for example usage.
+      # @return [Boolean] +true+ if all item keys has been processed, +false+ otherwise.
+      def complete?
+        unprocessed_keys.none?
+      end
+
+      # Returns an array of modeled items. The items are marshaled into classes used in {#find} method.
+      # These items will be unordered since DynamoDB does not return items in any particular order.
+      #
+      # See {Batch.read} for example usage.
+      # @return [Array] an array of modeled items from the +batch_get_item+ call.
+      def items
+        @items ||= []
+      end
+
+      private
+
+      def unprocessed_keys
+        @unprocessed_keys ||= []
+      end
+
+      def item_classes
+        @item_classes ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def format_unprocessed_key(klass, key)
+        item_key = {}
+        attributes = klass.attributes
+        klass.keys.each_value do |attr_sym|
+          unless key[attr_sym]
+            raise Errors::KeyMissing, "Missing required key #{attr_sym} in #{key}"
+          end
+
+          attr_name = attributes.storage_name_for(attr_sym)
+          item_key[attr_name] = attributes.attribute_for(attr_sym)
+                                          .serialize(key[attr_sym])
+        end
+        item_key
+      end
+
+      def store_unprocessed_key(klass, unprocessed_key)
+        unprocessed_keys << { keys: unprocessed_key, table_name: klass.table_name }
+      end
+
+      def store_item_class(klass, key)
+        if item_classes.include?(klass.table_name)
+          item_classes[klass.table_name].each do |item|
+            if item[:keys] == key && item[:class] != klass
+              raise ArgumentError, 'Provided item keys is a duplicate request'
+            end
+          end
+        end
+        item_classes[klass.table_name] << { keys: key, class: klass }
+      end
+
+      def build_operations(keys)
+        operations = Hash.new { |h, k| h[k] = { keys: [] } }
+        keys.each do |key|
+          operations[key[:table_name]][:keys] << key[:keys]
+        end
+        operations
+      end
+
+      def build_items(item_responses)
+        new_items = []
+        item_responses.each do |table, unprocessed_items|
+          unprocessed_items.each do |item|
+            item_class = find_item_class(table, item)
+            if item_class.nil? && @client.config.logger
+              @client.config.logger.warn(
+                'Unexpected response from service.'\
+                "Received: #{item}. Skipping above item and continuing"
+              )
+            else
+              new_items << build_item(item, item_class)
+            end
+          end
+        end
+        new_items
+      end
+
+      def update_unprocessed_keys(keys)
+        keys.each do |table_name, table_values|
+          table_values.keys.each do |key|
+            unprocessed_keys << { keys: key, table_name: table_name }
+          end
+        end
+      end
+
+      def find_item_class(table, item)
+        selected_item = item_classes[table].find { |item_info| contains_keys?(item, item_info[:keys]) }
+        selected_item[:class] if selected_item
+      end
+
+      def contains_keys?(item, keys)
+        item.merge(keys) == item
+      end
+
+      def build_item(item, item_class)
+        new_item_opts = {}
+        item.each do |db_name, value|
+          name = item_class.attributes.db_to_attribute_name(db_name)
+          new_item_opts[name] = value
+        end
+        item = item_class.new(new_item_opts)
+        item.clean!
+        item
+      end
+    end
+  end
+end