dyna_model 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e9716917403f2d28b549c5e9e9f1a7e144a2082
-  data.tar.gz: 779225e3e1a8ac16912436c339ee88595fa135f1
+  metadata.gz: 2739ba4513b27ea83ebe29ba3de12d9a3f96f1b0
+  data.tar.gz: 1277e4a3d77f03f82d27a06777fa05bc1b5fb122
 SHA512:
-  metadata.gz: aeb08a60336433d6c658d672ea18ae44ea191d3807a93d4d29d8282c24c9f7052510f05fe6661dd8b9cefeed7b06b20819c59fa8470e028c478109030d14a196
-  data.tar.gz: c10bc62289f546099b233261b47a3b450a0957bac194e0c1642e757932d8ea0db309cff1ba32c71032d3e60eef977d087ac102294594c27bb7833cb5a167a10a
+  metadata.gz: 4eee37ed2c9f653ed8ef651ff4c1e72625e8dbc480a75299752d0d236377ee2b69537f7e21b0a6ebfb278631c223d2e0cde07947b6bdf7b17736b3a7982a6792
+  data.tar.gz: f3518b6a0546434f24f54fb57cad8a1ba73cbcc6fd6720ade4d25b3d529b85662261732f5f7b86f90e2d6bbd8f65f0d909286e8a0de06abe805d4af3dbe8c9e0

data/README.md

@@ -7,6 +7,13 @@ AWS DynamoDB ORM for Rails based on AWS::Record in the aws-sdk gem. Still a work
 gem 'dyna_model'
 ```
 
+## Supports
+* Range Querying
+* Scans
+* Local Secondary Indexes
+* Global Secondary Indexes
+* Query Filtering
+
 ## Sample Model
 ```
 class Dude
@@ -70,10 +77,9 @@ Dude.create_table
 Dude.delete_table
 
 # Rake tasks
-rake ddb:create CLASS=Dude
 rake ddb:create CLASS=all
-rake ddb:destroy CLASS=Dude
 rake ddb:destroy CLASS=all
+rake ddb:resize CLASS=all
 ```
 
 ## Elasticsearch::Model compatible adapter

data/dyna_model.gemspec

@@ -26,6 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport', '>= 4.0.0'
   spec.add_dependency 'activemodel', '>= 4.0.0'
   spec.add_dependency 'rails', '>= 4.0.0'
-  spec.add_dependency 'aws-sdk', '>= 1.38.0'
+  spec.add_dependency 'aws-sdk', '>= 1.39.0'
 end
   

data/lib/dyna_model/document.rb

@@ -44,15 +44,69 @@ module DynaModel
         end
       end
 
+      # OVERRIDE
+      # https://github.com/aws/aws-sdk-ruby/blob/master/lib/aws/record/abstract_base.rb#L132
+      # pass options for 'expected'
+      public
+      def save opts = {}
+        if valid?(opts)
+          write_response = persisted? ? update(opts) : create(opts)
+          clear_changes!
+          if opts[:return_values] && opts[:return_values] != :none
+            # return the ReturnValues if the user wants them
+            write_response
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # OVERRIDE
+      # https://github.com/aws/aws-sdk-ruby/blob/master/lib/aws/record/abstract_base.rb#L176
+      # and pass options for 'expected'
+      public
+      def delete(options={})
+        if persisted?
+          if deleted?
+            raise 'unable to delete, this object has already been deleted'
+          else
+            resp = delete_storage(options)
+            @_deleted = true
+            resp
+          end
+        else
+          raise 'unable to delete, this object has not been saved yet'
+        end
+      end
+      alias_method :destroy, :delete
+
+      # OVERRIDE
+      # https://github.com/aws/aws-sdk-ruby/blob/master/lib/aws/record/abstract_base.rb#L265
+      # pass options for 'expected'
+      private
+      def create(options={})
+        # Not implemented
+        #populate_id
+        touch_timestamps('created_at', 'updated_at')
+        # Not implemented
+        #increment_optimistic_lock_value
+        @_persisted = true
+        create_storage(options)
+      end
+
       # OVERRIDE
       # https://github.com/aws/aws-sdk-ruby/blob/master/lib/aws/record/abstract_base.rb#L273
       # AWS::Record::AbstractBase to trigger update even without changes (for callbacks etc)
+      # and pass options for 'expected'
       private
-      def update
+      def update(options={})
         #return unless changed?
         touch_timestamps('updated_at')
-        increment_optimistic_lock_value
-        update_storage
+        # Not implemented
+        #increment_optimistic_lock_value
+        update_storage(options)
       end
     end
 

data/lib/dyna_model/extensions/s3_backup.rb

@@ -1,3 +1,4 @@
+# TODO: S3 key schema that allows for timestamp sorting
 #
 # Persist DynaModel records for a particular model to S3 for extra backup.
 #

data/lib/dyna_model/persistence.rb

@@ -15,16 +15,16 @@ module DynaModel
     end
 
     private
-    def create_storage
+    def create_storage(options={})
       run_callbacks :save do
         run_callbacks :create do
-          self.class.dynamo_db_table.write(serialize_attributes)
+          self.class.dynamo_db_table.write(serialize_attributes, options)
         end
       end
     end
 
     private
-    def update_storage
+    def update_storage(options={})
       # Only enumerating dirty (i.e. changed) attributes.  Empty
       # (nil and empty set) values are deleted, the others are replaced.
       run_callbacks :save do
@@ -40,21 +40,21 @@ module DynaModel
             end
           end
 
-          self.class.dynamo_db_table.write(attr_updates, {
+          self.class.dynamo_db_table.write(attr_updates, options.merge({
             update_item: dynamo_db_item_key_values,
             shard_name: self.shard
-          })
+          }))
         end
       end
     end
 
     private
-    def delete_storage
+    def delete_storage(options={})
       run_callbacks :destroy do
-        self.class.dynamo_db_table.delete_item(
+        self.class.dynamo_db_table.delete_item(options.merge(
           delete_item: dynamo_db_item_key_values,
           shard_name: self.shard
-        )
+        ))
       end
     end
 

data/lib/dyna_model/schema.rb

@@ -19,7 +19,7 @@ module DynaModel
         AWS::Record::Attributes::StringAttr => "S",
         AWS::Record::Attributes::IntegerAttr => "N",
         AWS::Record::Attributes::FloatAttr => "N",
-        AWS::Record::Attributes::BooleanAttr => "S",
+        AWS::Record::Attributes::BooleanAttr => "N",
         AWS::Record::Attributes::DateTimeAttr => "S",
         AWS::Record::Attributes::DateAttr => "S",
         AWS::Record::Attributes::SerializedAttr => "B"

data/lib/dyna_model/table.rb

@@ -18,6 +18,20 @@ module DynaModel
       ns: "NS"
     }
 
+    RETURN_VALUES = {
+      none: "NONE",
+      all_old: "ALL_OLD",
+      updated_old: "UPDATED_OLD",
+      all_new: "ALL_NEW",
+      updated_new: "UPDATED_NEW"
+    }
+
+    RETURN_VALUES_UPDATE_ONLY = [
+      :updated_old,
+      :all_new,
+      :updated_new
+    ]
+
     QUERY_SELECT = {
       all: "ALL_ATTRIBUTES",
       projected: "ALL_PROJECTED_ATTRIBUTES",
@@ -42,6 +56,11 @@ module DynaModel
       in: "IN"
     }
 
+    CONDITIONAL_OPERATOR = {
+      and: "AND",
+      or: "OR"
+    }
+
     COMPARISON_OPERATOR_SCAN_ONLY = [
       :ne, 
       :not_null,
@@ -51,24 +70,19 @@ module DynaModel
       :in
     ]
 
-    class << self
-
-
-    end
-
-      def self.type_from_value(value)
-        case
-        when value.kind_of?(AWS::DynamoDB::Binary) then :b
-        when value.respond_to?(:to_str) then :s
-        when value.kind_of?(Numeric) then :n
-        else
-          raise ArgumentError, "unsupported attribute type #{value.class}"
-        end
+    def self.type_from_value(value)
+      case
+      when value.kind_of?(AWS::DynamoDB::Binary) then :b
+      when value.respond_to?(:to_str) then :s
+      when value.kind_of?(Numeric) then :n
+      else
+        raise ArgumentError, "unsupported attribute type #{value.class}"
       end
+    end
 
-      def self.attr_with_type(attr_name, value)
-        { attr_name => { TYPE_INDICATOR[type_from_value(value)] => value.to_s } }
-      end
+    def self.attr_with_type(attr_name, value)
+      { attr_name => { TYPE_INDICATOR[type_from_value(value)] => value.to_s } }
+    end
 
     def initialize(model)
       @model = model
@@ -199,6 +213,7 @@ module DynaModel
       #AWS::DynamoDB::Errors::ValidationException: ALL_PROJECTED_ATTRIBUTES can be used only when Querying using an IndexName
       #options[:limit] ||= 10
       #options[:exclusive_start_key]
+      #options[:query_filter]
 
       key_conditions = {}
       gsi = nil
@@ -221,35 +236,33 @@ module DynaModel
       }
 
       if options[:range] 
-        raise ArgumentError, "Expected a 2 element Hash for :range (ex {:age.gt => 13})" unless options[:range].is_a?(Hash) && options[:range].keys.size == 1 && options[:range].keys.first.is_a?(String)
-        range_key_name, comparison_operator = options[:range].keys.first.split(".")
-        raise ArgumentError, "Comparison operator must be one of (#{(COMPARISON_OPERATOR.keys - COMPARISON_OPERATOR_SCAN_ONLY).join(", ")})" unless COMPARISON_OPERATOR.keys.include?(comparison_operator.to_sym)
-        range_key = @range_keys.find{|k| k[:attribute_name] == range_key_name}
+        raise ArgumentError, "Table does not use a range key in its schema!" if @range_keys.blank?
+        attr_with_condition_hash = self.attr_with_condition(options[:range])
+        range_key = @range_keys.find{|k| k[:attribute_name] == attr_with_condition_hash.keys.first}
         raise ArgumentError, ":range key must be a valid Range attribute" unless range_key
-        raise ArgumentError, ":range key must be a Range if using the operator BETWEEN" if comparison_operator == "between" && !options[:range].values.first.is_a?(Range)
 
         if range_key.has_key?(:index_name) # Local/Global Secondary Index
           options[:index_name] = range_key[:index_name]
           query_request[:index_name] = range_key[:index_name]
         end
 
-        range_value = options[:range].values.first
-        range_attribute_list = []
-        if comparison_operator == "between"
-          range_attribute_list << { range_key[:attribute_type] => range_value.min }
-          range_attribute_list << { range_key[:attribute_type] => range_value.max }
-        else
-          # TODO - support Binary?
-          range_attribute_list = [{ range_key[:attribute_type] => range_value.to_s }]
-        end
+        key_conditions.merge!(attr_with_condition_hash)
+      end
 
-        key_conditions.merge!({
-          range_key[:attribute_name] => {
-            attribute_value_list: range_attribute_list,
-            comparison_operator: COMPARISON_OPERATOR[comparison_operator.to_sym]
-          }
-        })
+      query_filter = {}
+      conditional_operator = nil
+      if options[:query_filter]
+        raise ArgumentError, ":query_filter must be a hash" unless options[:query_filter].is_a?(Hash)
+        options[:query_filter].each_pair do |k,v| 
+          query_filter.merge!(self.attr_with_condition({ k => v}))
+        end
+        if options[:conditional_operator]
+          raise ArgumentError, ":condition_operator invalid! Must be one of (#{CONDITIONAL_OPERATOR.keys.join(", ")})" unless CONDITIONAL_OPERATOR[options[:conditional_operator]]
+          conditional_operator = CONDITIONAL_OPERATOR[options[:conditional_operator]]
+        end
       end
+      query_request.merge!(query_filter: query_filter) unless query_filter.blank?
+      query_request.merge!(conditional_operator: conditional_operator) unless conditional_operator.blank? || query_filter.blank?
 
       if options[:global_secondary_index] # Override index_name if using GSI
         # You can only select projected attributes from a GSI
@@ -315,8 +328,22 @@ module DynaModel
 
     def write(attributes, options={})
       options[:return_consumed_capacity] ||= :none
+      options[:return_values] ||= :none
       options[:update_item] = false unless options[:update_item]
 
+      expected = {}
+      conditional_operator = nil
+      if options[:expected]
+        raise ArgumentError, ":expected must be a hash" unless options[:expected].is_a?(Hash)
+        options[:expected].each_pair do |k,v| 
+          expected.merge!(self.attr_with_condition({ k => v}))
+        end
+        if options[:conditional_operator]
+          raise ArgumentError, ":condition_operator invalid! Must be one of (#{CONDITIONAL_OPERATOR.keys.join(", ")})" unless CONDITIONAL_OPERATOR[options[:conditional_operator]]
+          conditional_operator = CONDITIONAL_OPERATOR[options[:conditional_operator]]
+        end
+      end
+
       if options[:update_item]
         # UpdateItem
         key_request = {
@@ -346,12 +373,16 @@ module DynaModel
             })
           end
         end
+        raise ArgumentError, ":return_values must be one of (#{RETURN_VALUES.keys.join(", ")})" unless RETURN_VALUES[options[:return_values]]
         update_item_request = {
           table_name: @model.dynamo_db_table_name(options[:shard_name]),
           key: key_request,
           attribute_updates: attrs_to_update,
-          return_consumed_capacity: RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]]
+          return_consumed_capacity: RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]],
+          return_values: RETURN_VALUES[options[:return_values]]
         }
+        update_item_request.merge!(expected: expected) unless expected.blank?
+        update_item_request.merge!(conditional_operator: conditional_operator) unless conditional_operator.blank? || expected.blank?
         @model.dynamo_db_client.update_item(update_item_request)
       else
         # PutItem
@@ -360,22 +391,30 @@ module DynaModel
           next if v.blank? # If empty string or nil, skip...
           items.merge!(self.class.attr_with_type(k,v))
         end
+        raise ArgumentError, ":return_values must be one of (#{(RETURN_VALUES.keys - RETURN_VALUES_UPDATE_ONLY).join(", ")})" unless RETURN_VALUES[options[:return_values]] && !RETURN_VALUES_UPDATE_ONLY.include?(options[:return_values])
         put_item_request = {
           table_name: @model.dynamo_db_table_name(options[:shard_name]),
           item: items,
-          return_consumed_capacity: RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]]
+          return_consumed_capacity: RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]],
+          return_values: RETURN_VALUES[options[:return_values]]
         }
+        put_item_request.merge!(expected: expected) unless expected.blank?
+        put_item_request.merge!(conditional_operator: conditional_operator) unless conditional_operator.blank? || expected.blank?
         @model.dynamo_db_client.put_item(put_item_request)
       end
     end
 
     def delete_item(options={})
       raise ":delete_item => {...key_values...} required" unless options[:delete_item].present?
+      options[:return_consumed_capacity] ||= :none
+      options[:return_values] ||= :none
+      raise ArgumentError, ":return_values must be one of (#{(RETURN_VALUES.keys - RETURN_VALUES_UPDATE_ONLY).join(", ")})" unless RETURN_VALUES[options[:return_values]] && !RETURN_VALUES_UPDATE_ONLY.include?(options[:return_values])
       key_request = {
         @hash_key[:attribute_name] => {
           @hash_key[:attribute_type] => options[:delete_item][:hash_value].to_s
         }
       }
+
       if @primary_range_key
         raise ArgumentError, "range_key was not provided to the delete_item command" if options[:delete_item][:range_value].blank?
         key_request.merge!({
@@ -384,10 +423,28 @@ module DynaModel
           }
         })
       end
+
+      expected = {}
+      conditional_operator = nil
+      if options[:expected]
+        raise ArgumentError, ":expected must be a hash" unless options[:expected].is_a?(Hash)
+        options[:expected].each_pair do |k,v| 
+          expected.merge!(self.attr_with_condition({ k => v}))
+        end
+        if options[:conditional_operator]
+          raise ArgumentError, ":condition_operator invalid! Must be one of (#{CONDITIONAL_OPERATOR.keys.join(", ")})" unless CONDITIONAL_OPERATOR[options[:conditional_operator]]
+          conditional_operator = CONDITIONAL_OPERATOR[options[:conditional_operator]]
+        end
+      end
+
       delete_item_request = {
         table_name: @model.dynamo_db_table_name(options[:shard_name]),
-        key: key_request
+        key: key_request,
+        return_consumed_capacity: RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]],
+        return_values: RETURN_VALUES[options[:return_values]]
       }
+      delete_item_request.merge!(expected: expected) unless expected.blank?
+      delete_item_request.merge!(conditional_operator: conditional_operator) unless conditional_operator.blank? || expected.blank?
       @model.dynamo_db_client.delete_item(delete_item_request)
     end
 
@@ -420,40 +477,68 @@ module DynaModel
 
       # :scan_filter => { :name.begins_with => "a" }
       scan_filter = {}
+      conditional_operator = nil
       if options[:scan_filter].present?
         options[:scan_filter].each_pair.each do |k,v|
-          # Hard to validate attribute types here, so infer by type sent and assume the user knows their own attrs
-          key_name, comparison_operator = k.split(".")
-          raise ArgumentError, "Comparison operator must be one of (#{COMPARISON_OPERATOR.keys.join(", ")})" unless COMPARISON_OPERATOR.keys.include?(comparison_operator.to_sym)
-          raise ArgumentError, "scan_filter value must be a Range if using the operator BETWEEN" if comparison_operator == "between" && !v.is_a?(Range)
-          raise ArgumentError, "scan_filter value must be a Array if using the operator IN" if comparison_operator == "in" && !v.is_a?(Array)
-
-          attribute_value_list = []
-          if comparison_operator == "in"
-            v.each do |in_v|
-              attribute_value_list << self.class.attr_with_type(key_name, in_v).values.last
-            end
-          elsif comparison_operator == "between"
-            attribute_value_list << self.class.attr_with_type(key_name, v.min).values.last
-            attribute_value_list << self.class.attr_with_type(key_name, v.max).values.last
-          else
-            attribute_value_list << self.class.attr_with_type(key_name, v).values.last
-          end
-          scan_filter.merge!({
-            key_name => {
-              comparison_operator: COMPARISON_OPERATOR[comparison_operator.to_sym],
-              attribute_value_list: attribute_value_list
-            }
-          })
+          scan_filter.merge!(self.attr_with_condition({ k => v}))
         end
-        scan_request.merge!(scan_filter: scan_filter)
       end
-
-      scan_request.merge!({ segment: options[:segment].to_i }) if options[:segment].present?
-      scan_request.merge!({ total_segments: options[:total_segments].to_i }) if options[:total_segments].present?
+      if options[:conditional_operator]
+        raise ArgumentError, ":condition_operator invalid! Must be one of (#{CONDITIONAL_OPERATOR.keys.join(", ")})" unless CONDITIONAL_OPERATOR[options[:conditional_operator]]
+        conditional_operator = CONDITIONAL_OPERATOR[options[:conditional_operator]]
+      end
+      scan_request.merge!(scan_filter: scan_filter) unless scan_filter.blank?
+      scan_request.merge!(conditional_operator: conditional_operator) unless conditional_operator.blank? || scan_filter.blank?
+      scan_request.merge!(segment: options[:segment].to_i) if options[:segment].present?
+      scan_request.merge!(total_segments: options[:total_segments].to_i) if options[:total_segments].present?
 
       @model.dynamo_db_client.scan(scan_request)
     end
 
+    protected
+
+    # {:name.eq => "cary"}
+    #
+    # return:
+    #   {
+    #     "name" => {
+    #       attribute_value_list: [
+    #         "S" => "cary"
+    #       ],
+    #       comparison_operator: "EQ"
+    #     }
+    #   }
+    def attr_with_condition(attr_conditional)
+      raise ArgumentError, "Expected a 2 element Hash for each :query_filter (ex {:age.gt => 13})" unless attr_conditional.is_a?(Hash) && attr_conditional.keys.size == 1 && attr_conditional.keys.first.is_a?(String)
+      attr_name, comparison_operator = attr_conditional.keys.first.split(".")
+      raise ArgumentError, "Comparison operator must be one of (#{(COMPARISON_OPERATOR.keys - COMPARISON_OPERATOR_SCAN_ONLY).join(", ")})" unless COMPARISON_OPERATOR.keys.include?(comparison_operator.to_sym)
+      attr_key = @model.attributes[attr_name]
+      raise ArgumentError, "#{attr_name} not a valid attribute" unless attr_key
+      attr_type = @model.attribute_type_indicator(attr_key)
+      raise ArgumentError, "#{attr_name} key must be a Range if using the operator BETWEEN" if comparison_operator == "between" && !attr_conditional.values.first.is_a?(Range)
+      raise ArgumentError, ":query_filter value must be an Array if using the operator IN" if comparison_operator == "in" && !attr_conditional.values.first.is_a?(Array)
+
+      attr_value = attr_conditional.values.first
+
+      attribute_value_list = []
+      if comparison_operator == "in"
+        attr_conditional.values.first.each do |in_v|
+          attribute_value_list << { attr_type => in_v.to_s }
+        end
+      elsif comparison_operator == "between"
+        attribute_value_list << { attr_type => attr_value.min.to_s }
+        attribute_value_list << { attr_type => attr_value.max.to_s }
+      else
+        attribute_value_list = [{ attr_type => attr_value.to_s }]
+      end
+
+      attribute_comparison_hash = {
+        comparison_operator: COMPARISON_OPERATOR[comparison_operator.to_sym]
+      }
+      attribute_comparison_hash.merge!(attribute_value_list: attribute_value_list) unless %w(null not_null).include?(comparison_operator)
+
+      { attr_name => attribute_comparison_hash }
+    end
+
   end
 end

data/lib/dyna_model/version.rb

@@ -1,3 +1,3 @@
 module DynaModel
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/dyna_model/persistence_spec.rb

@@ -3,6 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe "DynaModel::Persistence" do
 
   before do
+    User.delete_table
     User.create_table
     @user = User.new
     @user_attrs = {
@@ -78,4 +79,31 @@ describe "DynaModel::Persistence" do
     User.read("hash", 3).should be_nil
   end
 
+  it 'should respect :expected in a save' do
+    user = User.new(@user_attrs)
+
+    expect {
+      user.save
+    }.not_to raise_error
+
+    expect {
+      user.save(expected: {:name.eq => "wrongname"})
+    }.to raise_error(AWS::DynamoDB::Errors::ConditionalCheckFailedException)
+
+    user.save(expected: {:name.eq => "Kate"}, return_values: :all_old).should be_a AWS::Core::Response
+  end
+
+  it 'should respect :expected in a destroy' do
+    user = User.new(@user_attrs)
+    user.save
+
+    expect {
+      user.delete(expected: {:name.eq => "wrongname"})
+    }.to raise_error(AWS::DynamoDB::Errors::ConditionalCheckFailedException)
+
+    expect {
+      user.delete(expected: {:name.eq => "Kate"})
+    }.not_to raise_error
+  end
+
 end

data/spec/dyna_model/query_spec.rb

@@ -80,6 +80,17 @@ describe "DynaModel::Query" do
     users.first.name.should == "Cary"
   end
 
+  it 'should read_range with :query_filter' do
+    @user = User.create(@user_attrs)
+    @user2 = User.create(@user2_attrs)
+    users = User.read_range("Dunn", query_filter: {:name.eq => "Cary"})
+    users.length.should == 1
+    users.first.name.should == "Cary"
+    users = User.read_range("Dunn", query_filter: {:name.in => ["Cary"]})
+    users.length.should == 1
+    users.first.name.should == "Cary"
+  end
+
   it 'should read_first' do
     @user = User.create(@user_attrs)
     User.read_first("Dunn", order: :asc).name.should == "Kate"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dyna_model
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Cary Dunn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.38.0
+        version: 1.39.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.38.0
+        version: 1.39.0
 description: DyanmoDB ORM on AWS::Record
 email:
 - cary.dunn@gmail.com