toy-dynamo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a7c12efaf31f18e82b7f7eb008ef7e78c564551
+  data.tar.gz: 6a756b5cd20bee61f2e1e9b9b56ce79b4f5e6b88
+SHA512:
+  metadata.gz: f2047d2af54e2e2697bd146f29dda06da93f86c4309306313700225425ae367daec3039e10be63a705633e614ccb235df38653a7de4be2b049139ee3dc6f2488
+  data.tar.gz: 7642b6a3cf88648a184b5e1aff30658fb760f479cc34950e06be65d44c278e92b9dab30842f67dbd7d097b321be7b5f4c62dd1ef5e030dc4839f87d83bccff1d

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+*.swo

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in toy-dynamo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Cary Dunn
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+## Install
+* toystore gem
+	* originally [https://github.com/jnunemaker/toystore](https://github.com/jnunemaker/toystore)
+	* Rails 4 compat: [https://github.com/cdunn/toystore](https://github.com/cdunn/toystore) (until merge)
+* Official [aws-sdk](http://aws.amazon.com/sdkforruby/) gem
+
+## Config
+In ActiveModel model:
+
+```
+dynamo_table do
+	adapter :dynamo, AWS::DynamoDB::ClientV2.new, {:model => self}
+	hash_key :thread_guid
+end
+```
+* **Other options:**
+	* range_key :comment_id
+	* table_name "user_dynamo_table"
+	* read_provision 20
+    * write_provision 10
+	* local_secondary_index :created_at
+		* :projection => :keys_only **[default]**
+		* :projection => :all
+		* Can also specify an Array of attributes to project besides the primary keys ex:
+			* :projection => [:subject, :commenter_name]
+
+## Usage
+* **Read Hash Key Only**
+	* Example:
+		* Model.read("xyz")
+		* Model.read("xyz", :consistent_read => true)
+* **Read Hash + Range**
+	* Example:
+		* Model.read("xyz", :range_value => "123")
+		* Model.read("xyz", :range_value => "123", :consistent_read => true)
+* **Read Multiple Hash Key Only**
+	* Example:
+		* Model.read_multiple(["abc", "xyz"])
+	* **Returns** Hash of Hash Keys => Object
+* **Read Multiple Hash + Range**
+	* Example:
+		* Model.read_multiple([{:hash_value => "xyz", :range_value => "123"}, {:hash_value => "xyz", :range_value => "456"}], :consistent_read => true)
+	* Assumes all the same table
+	* Runs queries using the batch_get_item API call
+	* Limited to 100 items max (or 1MB result size)
+	* **Returns** Hash of Hash Keys => Hash of Range keys => Object
+* **Read Range**
+	* Example:
+		* Model.read_range("xyz", :range => {:comment_id.eq => "123"})
+		* Model.read_range("xyz", :range => {:comment_id.gte => "123"})
+		* Model.read_range("xyz") (any range)
+	* If expecting lots of results, use batch and limit
+		* Model.read_range("xyz", :batch => 10, :limit => 100)
+			* Read 10 at a time up to a max of 100 items
+		* Model.read_range("xyz", :limit => 10)
+			* Read max 10 items in one request
+* **Count Range**
+	* Example:
+		* Model.count_range("xyz", :range => {:comment_id.eq => "123"})
+	* Returns the number of total results (no attributes)
+
+## Compatibility
+* Tested with
+	* Rails 4
+	* Ruby 2.0.0p0
+
+## TODO
+* raise error if trying to use an attribute that wasn't 'select'ed (defaulting to selecting all attributes which loads everything with an extra read)
+* while loop for situation where batch_get_item returns batched results
+* error out on mismatch of table schema from dynamo_table schema (changed?)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/toy/dynamo/adapter.rb

@@ -0,0 +1,58 @@
+require 'adapter'
+
+module Toy
+  module Dynamo
+    module Adapter
+      def read(key, options=nil)
+        options ||= {}
+        attrs = nil
+        if @options[:model].dynamo_table.range_keys.present?
+          raise ArgumentError, "Expected :range_value option" unless options[:range_value].present?
+          result = @options[:model].dynamo_table.query(key, options.merge(
+            :range => {
+              "#{@options[:model].dynamo_table.range_keys.find{|k| k[:primary_range_key] }[:attribute_name]}".to_sym.eq => options[:range_value]
+            }
+          ))
+          attrs = (result[:member].empty? ? nil : Response.strip_attr_types(result[:member].first))
+        else
+          result = @options[:model].dynamo_table.get_item(key, options)
+          attrs = (result[:item].empty? ? nil : Response.strip_attr_types(result[:item]))
+        end
+
+        attrs
+      end
+
+      def batch_read(keys, options=nil)
+        options ||= {}
+        @options[:model].dynamo_table.batch_get_item(keys, options)
+      end
+
+      def write(key, attributes, options=nil)
+        options ||= {}
+        @options[:model].dynamo_table.write(key, attributes, options)
+      end
+
+      def delete(key, options=nil)
+        options ||= {}
+        @options[:model].dynamo_table.delete_item(key, options)
+      end
+
+      def clear(options=nil)
+        @options[:model].dynamo_table.delete
+      end
+
+      private
+
+      def attributes_from_result(result)
+        attrs = {}
+        result.each_pair do |k,v|
+          attrs[k] = v.values.first
+        end
+        attrs
+      end
+
+    end
+  end
+end
+
+Adapter.define(:dynamo, Toy::Dynamo::Adapter)

data/lib/toy/dynamo/attributes.rb

@@ -0,0 +1,29 @@
+module Toy
+  module Attributes
+
+    # [OVERRIDE] 'write_attribute' to account for setting hash_key and id to same value
+    # u.id = 1
+    # * set id to 1
+    # * set hash_key to 1
+    # u.hash_key = 2
+    # * set hash_key to 2
+    # * set id to 2
+    def write_attribute(key, value)
+      key = key.to_s
+      attribute = attribute_instance(key)
+
+      if self.class.dynamo_table.hash_key[:attribute_name] != "id" # If primary hash_key is not the standard `id`
+        if key == self.class.dynamo_table.hash_key[:attribute_name]
+          @attributes[key] = attribute_instance(key).from_store(value)
+          return @attributes["id"] = attribute_instance("id").from_store(value)
+        elsif key == "id"
+          @attributes["id"] = attribute_instance("id").from_store(value)
+          return @attributes[self.class.dynamo_table.hash_key[:attribute_name]] = attribute_instance(self.class.dynamo_table.hash_key[:attribute_name]).from_store(value)
+        end
+      end
+
+      @attributes[key] = attribute.from_store(value)
+    end
+
+  end
+end

data/lib/toy/dynamo/extensions/array.rb

@@ -0,0 +1,14 @@
+module Toy
+  module Extensions
+    module Array
+      def to_store(value, *)
+        value = value.respond_to?(:lines) ? value.lines : value
+        Marshal.dump(value.to_a)
+      end
+
+      def from_store(value, *)
+        value.nil? ? store_default : (value.class.is_a?(Array) ? value : Marshal.load(value))
+      end
+    end
+  end
+end

data/lib/toy/dynamo/extensions/boolean.rb

@@ -0,0 +1,14 @@
+module Toy
+  module Extensions
+    module Boolean
+      def to_store(value, *)
+        boolean_value = value.is_a?(Boolean) ? value : Mapping[value]
+        boolean_value ? 't' : 'f'
+      end
+
+      def from_store(value, *)
+        Mapping[value]
+      end
+    end
+  end
+end

data/lib/toy/dynamo/extensions/date.rb

@@ -0,0 +1,21 @@
+module Toy
+  module Extensions
+    module Date
+      def to_store(value, *)
+        if value.nil? || value == ''
+          nil
+        else
+          date = value.is_a?(::Date) || value.is_a?(::Time) ? value : ::Date.parse(value.to_s)
+          #::Time.utc(date.year, date.month, date.day)
+          date.to_i
+        end
+      rescue
+        nil
+      end
+
+      def from_store(value, *)
+        Time.at(value.to_i).to_date if value.present?
+      end
+    end
+  end
+end

data/lib/toy/dynamo/extensions/hash.rb

@@ -0,0 +1,13 @@
+module Toy
+  module Extensions
+    module Hash
+      def to_store(value, *)
+        Marshal.dump(value)
+      end
+
+      def from_store(value, *)
+        value.nil? ? store_default : (value.class.is_a?(Hash) ? value : Marshal.load(value))
+      end
+    end
+  end
+end

data/lib/toy/dynamo/extensions/set.rb

@@ -0,0 +1,17 @@
+module Toy
+  module Extensions
+    module Set
+      def store_default
+        [].to_set
+      end
+
+      def to_store(value, *)
+        Marshal.dump(value)
+      end
+
+      def from_store(value, *)
+        value.nil? ? store_default : Marshal.load(value)
+      end
+    end
+  end
+end

data/lib/toy/dynamo/extensions/symbol.rb

@@ -0,0 +1,11 @@
+class Symbol
+
+  Toy::Dynamo::Table::COMPARISON_OPERATOR.keys.each do |oper|
+    class_eval <<-OPERATORS
+      def #{oper}
+        "\#\{self.to_s\}.#{oper}"
+      end
+    OPERATORS
+  end
+
+end

data/lib/toy/dynamo/extensions/time.rb

@@ -0,0 +1,25 @@
+module Toy
+  module Extensions
+    module Time
+      def to_store(value, *)
+        if value.nil? || value == ''
+          nil
+        else
+          time_class = ::Time.try(:zone).present? ? ::Time.zone : ::Time
+          time = value.is_a?(::Time) ? value : time_class.parse(value.to_s)
+          # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
+          time.to_i if time
+        end
+      end
+
+      def from_store(value, *)
+        value = ::Time.at(value.to_i)
+        if ::Time.try(:zone).present? && value.present?
+          value.in_time_zone(::Time.zone)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/toy/dynamo/persistence.rb

@@ -0,0 +1,41 @@
+module Toy
+  module Persistence
+
+    def persisted_attributes
+      attributes_with_values = {}
+      attributes_to_persist = []
+
+      if self.new_record?
+        attributes_to_persist = self.class.persisted_attributes
+      else
+        attributes_to_persist = self.class.persisted_attributes.select { |a|
+          # Persist changed attributes and always the range key if applicable (for lookup)
+          self.changed_attributes.keys.include?(a.name) || (self.class.dynamo_table.range_keys && self.class.dynamo_table.range_keys.find{|k| k[:primary_range_key]}[:attribute_name] == a.name)
+        }
+      end
+
+      attributes_to_persist.each do |attribute|
+        if (value = attribute.to_store(read_attribute(attribute.name)))
+          attributes_with_values[attribute.persisted_name] = value
+        end
+      end
+
+      attributes_with_values
+    end
+
+    def persist
+      adapter.write(persisted_id, persisted_attributes, {:update_item => !self.new_record?})
+    end
+
+    def delete
+      @_destroyed = true
+      options = {}
+      if self.class.dynamo_table.range_keys
+        range_key = self.class.dynamo_table.range_keys.find{|k| k[:primary_range_key]}
+        options[:range_value] = read_attribute(range_key[:attribute_name])
+      end
+      adapter.delete(persisted_id, options)
+    end
+
+  end
+end

data/lib/toy/dynamo/querying.rb

@@ -0,0 +1,82 @@
+module Toy
+  module Dynamo
+    module Querying
+      extend ActiveSupport::Concern
+
+      # Failsafe
+      MAX_BATCH_ITERATIONS = 100
+
+      module ClassMethods
+
+        # Read results up to the limit
+        #   read_range("1", :range_value => "2", :limit => 10)
+        # Loop results in given batch size until limit is hit or no more results
+        #   read_range("1", :range_value => "2", :batch => 10, :limit => 1000)
+        def read_range(hash_value, options={})
+          raise ArgumentError, "no range_key specified for this table" if dynamo_table.range_keys.blank?
+          aggregated_results = []
+
+          if (batch_size = options.delete(:batch))
+            max_results_limit = options[:limit]
+            if options[:limit] && options[:limit] > batch_size
+              options.merge!(:limit => batch_size)
+            end
+          end
+          results = dynamo_table.query(hash_value, options)
+          response = Response.new(results)
+
+          results[:member].each do |result|
+            attrs = Response.strip_attr_types(result)
+            aggregated_results << load(attrs[dynamo_table.hash_key[:attribute_name]], attrs)
+          end
+
+          if batch_size
+            results_returned = response.count
+            batch_iteration = 0
+            while response.more_results? && batch_iteration < MAX_BATCH_ITERATIONS
+              if max_results_limit && (delta_results_limit = (max_results_limit-results_returned)) < batch_size
+                break if delta_results_limit == 0
+                options.merge!(:limit => delta_results_limit)
+              else
+                options.merge!(:limit => batch_size)
+              end
+
+              results = dynamo_table.query(hash_value, options.merge(:exclusive_start_key => response.last_evaluated_key))
+              response = Response.new(results)
+              results[:member].each do |result|
+                attrs = Response.strip_attr_types(result)
+                aggregated_results << load(attrs[dynamo_table.hash_key[:attribute_name]], attrs)
+              end
+              results_returned += response.count
+              batch_iteration += 1
+            end
+          end
+
+          aggregated_results
+        end
+
+        def count_range(hash_value, options={})
+          raise ArgumentError, "no range_key specified for this table" if dynamo_table.range_keys.blank?
+          results = dynamo_table.query(hash_value, options.merge(:select => :count))
+          Response.new(results).count
+        end
+
+        def read_multiple(keys, options=nil)
+          results_map = {}
+          results = adapter.batch_read(keys, options)
+          results[:responses][dynamo_table.table_schema[:table_name]].each do |result|
+            attrs = Response.strip_attr_types(result)
+            if dynamo_table.range_keys.present?
+              (results_map[attrs[dynamo_table.hash_key[:attribute_name]]] ||= {})[attrs[dynamo_table.range_keys.find{|rk| rk[:primary_range_key] }[:attribute_name]]] = load(attrs[dynamo_table.hash_key[:attribute_name]], attrs)
+            else
+              results_map[attrs[dynamo_table.hash_key[:attribute_name]]] = load(attrs[dynamo_table.hash_key[:attribute_name]], attrs)
+            end
+          end
+          results_map
+        end
+
+      end # ClassMethods
+
+    end
+  end
+end

data/lib/toy/dynamo/response.rb

@@ -0,0 +1,38 @@
+module Toy
+  module Dynamo
+    class Response
+
+      def initialize(response)
+        raise ArgumentError, "response should be an AWS::Core::Response" unless response.is_a?(AWS::Core::Response)
+        @raw_response = response
+      end
+
+      #def values_from_response_hash(options = {})
+        #@raw_response.inject({}) do |h, (key, value_hash)|
+          #h.update(key => value_hash.to_a.last)
+        #end
+      #end
+
+      def count
+        @raw_response[:count]
+      end
+
+      def last_evaluated_key
+        @raw_response[:last_evaluated_key]
+      end
+
+      def more_results?
+        @raw_response.has_key?(:last_evaluated_key)
+      end
+
+      def self.strip_attr_types(hash)
+        attrs = {}
+        hash.each_pair do |k,v|
+          attrs[k] = v.values.first
+        end
+        attrs
+      end
+
+    end
+  end
+end

data/lib/toy/dynamo/schema.rb

@@ -0,0 +1,212 @@
+module Toy
+  module Dynamo
+    module Schema
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        KEY_TYPE = {
+          :hash => "HASH",
+          :range => "RANGE"
+        }
+
+        PROJECTION_TYPE = {
+          :keys_only => "KEYS_ONLY",
+          :all => "ALL",
+          :include => "INCLUDE"
+        }
+
+        def dynamo_table(&block)
+          if block
+            @dynamo_table_config_block ||= block
+          else
+            @dynamo_table_config_block.call unless @dynamo_table_configged
+
+            @dynamo_table ||= Table.new(table_schema, self.adapter.client)
+            @dynamo_table_configged = true
+            @dynamo_table
+          end
+        end
+
+        def table_schema
+          schema = {
+            :table_name => table_name,
+            :provisioned_throughput => {
+              :read_capacity_units => read_provision,
+              :write_capacity_units => write_provision
+            },
+            :key_schema => key_schema,
+            :attribute_definitions => attribute_definitions
+          }
+          schema.merge!(:local_secondary_indexes => local_secondary_indexes) unless local_secondary_indexes.blank?
+          schema
+        end
+
+        def table_name(val=nil)
+          if val
+            raise(ArgumentError, "Invalid table name") unless val
+            @dynamo_table_name = val
+          else
+            @dynamo_table_name ||= "#{Rails.application.class.parent_name.to_s.underscore.dasherize}-#{self.to_s.underscore.dasherize.pluralize}-#{Rails.env}"
+            @dynamo_table_name
+          end
+        end
+
+        def read_provision(val=nil)
+          if val
+            raise(ArgumentError, "Invalid read provision") unless val.to_i >= 1
+            @dynamo_read_provision = val.to_i
+          else
+            @dynamo_read_provision || 10
+          end
+        end
+
+        def write_provision(val=nil)
+          if val
+            raise(ArgumentError, "Invalid write provision") unless val.to_i >= 1
+            @dynamo_write_provision = val.to_i
+          else
+            @dynamo_write_provision || 10
+          end
+        end
+
+        # TODO - need to add projections?
+        def attribute_definitions
+          # Keys for hash/range/secondary
+          # S | N | B
+          #{:attribute_name => , :attribute_type => }
+
+          keys = []
+          keys << hash_key[:attribute_name]
+          keys << range_key[:attribute_name] if range_key
+          local_secondary_indexes.each do |lsi|
+            keys << lsi[:key_schema].select{|h| h[:key_type] == "RANGE"}.first[:attribute_name]
+          end
+
+          definitions = keys.uniq.collect do |k|
+            attr = self.attributes[k.to_s]
+            {
+              :attribute_name => attr.name,
+              :attribute_type => attribute_type_indicator(attr.type)
+            }
+          end
+        end
+
+        def attribute_type_indicator(type)
+          if type == Array
+            "S"
+          elsif type == Boolean
+            "S"
+          elsif type == Date
+            "N"
+          elsif type == Float
+            "N"
+          elsif type == Hash
+            "S"
+          elsif type == Integer
+            "N"
+          elsif type == Object
+            "S"
+          elsif type == Set
+            "S"
+          elsif type == String
+            "S"
+          elsif type == Time
+            "N"
+          elsif type == SimpleUUID::UUID
+            "S"
+          else
+            raise "unsupported attribute type #{type}"
+          end
+        end
+
+        def key_schema
+          raise(ArgumentError, 'hash_key was not set for this table') if @dynamo_hash_key.blank?
+          schema = [hash_key]
+          schema << range_key if range_key 
+          schema
+        end
+
+        def hash_key(hash_key_key=nil)
+          if hash_key_key
+            hash_key_attribute = self.attributes[hash_key_key.to_s]
+            raise(ArgumentError, "Could not find attribute definition for hash_key #{hash_key_key}") unless hash_key_attribute
+            raise(ArgumentError, "Cannot use virtual attributes for hash_key") if hash_key_attribute.virtual?
+            @dynamo_hash_key = {
+              :attribute_name => hash_key_attribute.name,
+              :key_type => KEY_TYPE[:hash]
+            }
+          else
+            @dynamo_hash_key
+          end
+        end
+
+        def range_key(range_key_key=nil)
+          if range_key_key
+            range_key_attribute = self.attributes[range_key_key.to_s]
+            raise(ArgumentError, "Could not find attribute definition for range_key #{range_key_key}") unless range_key_attribute
+            raise(ArgumentError, "Cannot use virtual attributes for range_key") if range_key_attribute.virtual?
+
+            validates_presence_of range_key_attribute.name.to_sym
+
+            @dynamo_range_key = {
+              :attribute_name => range_key_attribute.name,
+              :key_type => KEY_TYPE[:range]
+            }
+          else
+            @dynamo_range_key
+          end
+        end
+
+        def local_secondary_indexes
+          @local_secondary_indexes ||= []
+        end
+
+        # @param [Symbol] index_attr the attribute to index secondary
+        # @param [Hash] options
+        # @option options [Symbol, Array<String>] :projection
+        #   * `:all` 
+        #   * `:keys_only` 
+        #   * [:attributes to project]
+        def local_secondary_index(range_key_attr, options={})
+          options[:projection] ||= :keys_only
+          local_secondary_index_hash = {
+            :projection => {}
+          }
+          if options[:projection].is_a?(Array) && options[:projection].size > 0
+            options[:projection].each do |non_key_attr|
+              attr = self.attributes[non_key_attr.to_s]
+              raise(ArgumentError, "Could not find attribute definition for projection on #{non_key_attr}") unless attr
+              (local_secondary_index_hash[:projection][:non_key_attributes] ||= []) << attr.name
+            end
+            local_secondary_index_hash[:projection][:projection_type] = PROJECTION_TYPE[:include]
+          else
+            raise(ArgumentError, 'projection must be :all, :keys_only, Array (or attrs)') unless options[:projection] == :keys_only || options[:projection] == :all
+            local_secondary_index_hash[:projection][:projection_type] = PROJECTION_TYPE[options[:projection]]
+          end
+
+          range_attr = self.attributes[range_key_attr.to_s]
+          raise(ArgumentError, "Could not find attribute definition for local secondary index on #{range_key_attr}") unless range_attr
+          local_secondary_index_hash[:index_name] = (options[:name] || "#{range_attr.name}_index".camelcase)
+
+          hash_key_attr = self.attributes[hash_key[:attribute_name].to_s]
+          raise(ArgumentError, "Could not find attribute definition for hash_key") unless hash_key_attr
+
+          local_secondary_index_hash[:key_schema] = [
+            {
+              :attribute_name => hash_key_attr.name,
+              :key_type => KEY_TYPE[:hash]
+            },
+            {
+              :attribute_name => range_attr.name,
+              :key_type => KEY_TYPE[:range]
+            }
+          ]
+          (@local_secondary_indexes ||= []) << local_secondary_index_hash
+        end
+
+      end # ClassMethods
+
+    end
+  end
+end

data/lib/toy/dynamo/table.rb

@@ -0,0 +1,359 @@
+module Toy
+  module Dynamo
+    class Table
+
+      attr_reader :table_schema, :client, :schema_loaded, :hash_key, :range_keys
+
+      RETURNED_CONSUMED_CAPACITY = {
+        :none => "NONE",
+        :total => "TOTAL"
+      }
+
+      TYPE_INDICATOR = {
+        :b => "B",
+        :n => "N",
+        :s => "S",
+        :ss => "SS",
+        :ns => "NS"
+      }
+
+      QUERY_SELECT = {
+        :all => "ALL_ATTRIBUTES",
+        :projected => "ALL_PROJECTED_ATTRIBUTES",
+        :count => "COUNT",
+        :specific => "SPECIFIC_ATTRIBUTES"
+      }
+
+      COMPARISON_OPERATOR = {
+        :eq => "EQ",
+        :le => "LE",
+        :lt => "LT",
+        :ge => "GE",
+        :gt => "GT",
+        :begins_with => "BEGINS_WITH",
+        :between => "BETWEEN"
+      }
+
+      def initialize(table_schema, client)
+        @table_schema = table_schema
+        @client = client
+        begin
+          self.load_schema
+        rescue AWS::DynamoDB::Errors::ResourceNotFoundException => e
+          puts "No table found! Creating..."
+          self.create
+          self.load_schema
+        end
+      end
+
+      def load_schema
+        @schema_loaded = @client.describe_table(:table_name => @table_schema[:table_name])
+
+        @schema_loaded[:table][:key_schema].each do |key|
+          key_schema_attr = {
+            :attribute_name => key[:attribute_name],
+            :attribute_type => @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == key[:attribute_name]}[:attribute_type]
+          }
+
+          if key[:key_type] == "HASH"
+            @hash_key = key_schema_attr
+          else
+            (@range_keys ||= []) << key_schema_attr.merge(:primary_range_key => true)
+          end
+        end
+
+        if @schema_loaded[:table][:local_secondary_indexes]
+          @schema_loaded[:table][:local_secondary_indexes].each do |key|
+            lsi_range_key = key[:key_schema].find{|h| h[:key_type] == "RANGE" }
+            (@range_keys ||= []) << {
+              :attribute_name => lsi_range_key[:attribute_name],
+              :attribute_type => @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == lsi_range_key[:attribute_name]}[:attribute_type],
+              :index_name => key[:index_name]
+            }
+          end
+        end
+
+        @schema_loaded
+      end
+
+      def hash_key_item_param(value)
+        hash_key = @table_schema[:key_schema].find{|h| h[:key_type] == "HASH"}[:attribute_name]
+        hash_key_type = @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == hash_key}[:attribute_type]
+        { hash_key => { hash_key_type => value } }
+      end
+
+      def hash_key_condition_param(value)
+        hash_key = @table_schema[:key_schema].find{|h| h[:key_type] == "HASH"}[:attribute_name]
+        hash_key_type = @table_schema[:attribute_definitions].find{|h| h[:attribute_name] == hash_key}[:attribute_type]
+        {
+          hash_key => {
+            :attribute_value_list => [hash_key_type => value],
+            :comparison_operator => COMPARISON_OPERATOR[:eq]
+          }
+        }
+      end
+
+      def attr_with_type(attr_name, value)
+        { attr_name => { TYPE_INDICATOR[type_from_value(value)] => value.to_s } }
+      end
+
+      def get_item(hash_key, options={})
+        options[:consistent_read] = false unless options[:consistent_read]
+        options[:return_consumed_capacity] ||= :none # "NONE" # || "TOTAL"
+        options[:select] ||= []
+
+        get_item_request = {
+          :table_name => options[:table_name] || @table_schema[:table_name],
+          :key => hash_key_item_param(hash_key),
+          :consistent_read => options[:consistent_read],
+          :return_consumed_capacity => RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]]
+        }
+        get_item_request.merge!( :attributes_to_get => [options[:select]].flatten ) unless options[:select].blank?
+        @client.get_item(get_item_request)
+      end
+
+      # == options
+      #    * consistent_read
+      #    * return_consumed_capacity
+      #    * order
+      #    * select
+      #    * range
+      def query(hash_key_value, options={})
+        options[:consistent_read] = false unless options[:consistent_read]
+        options[:return_consumed_capacity] ||= :none # "NONE" # || "TOTAL"
+        options[:order] ||= :desc
+        #options[:index_name] ||= :none
+        #AWS::DynamoDB::Errors::ValidationException: ALL_PROJECTED_ATTRIBUTES can be used only when Querying using an IndexName
+        #options[:limit] ||= 10
+        #options[:exclusive_start_key]
+
+        key_conditions = {}
+        key_conditions.merge!(hash_key_condition_param(hash_key_value))
+
+        query_request = {
+          :table_name => options[:table_name] || @table_schema[:table_name],
+          :key_conditions => key_conditions,
+          :consistent_read => options[:consistent_read],
+          :return_consumed_capacity => RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]],
+          :scan_index_forward => (options[:order] == :asc)
+        }
+
+        if options[:range] 
+          raise ArgumentError, "Expected a 1 element Hash for :range (ex {:age.gt => 13})" unless options[:range].is_a?(Hash) && options[:range].keys.size == 1
+          range_key_name, comparison_operator = options[:range].keys.first.split(".")
+          raise ArgumentError, "Comparison operator must be one of (#{COMPARISON_OPERATOR.keys.join(", ")})" unless COMPARISON_OPERATOR.keys.include?(comparison_operator.to_sym)
+          range_key = @range_keys.find{|k| k[:attribute_name] == range_key_name}
+          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 Secondary Index
+            #options[:select] = :projected unless options[:select].present?
+            query_request.merge!(: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!({
+            range_key[:attribute_name] => {
+              :attribute_value_list => range_attribute_list,
+              :comparison_operator => COMPARISON_OPERATOR[comparison_operator.to_sym]
+            }
+          })
+        end
+
+        # Default if not already set
+        options[:select] ||= :all # :all, :projected, :count, []
+        if options[:select].is_a?(Array)
+          attrs_to_select = [options[:select].map(&:to_s)].flatten
+          attrs_to_select << @hash_key[:attribute_name]
+          attrs_to_select << @range_keys.find{|k| k[:primary_range_key] }[:attribute_name] if @range_keys
+          query_request.merge!({
+            :select => QUERY_SELECT[:specific],
+            :attributes_to_get => attrs_to_select.uniq
+          })
+        else
+          query_request.merge!({ :select => QUERY_SELECT[options[:select]] })
+        end
+        
+        query_request.merge!({ :limit => options[:limit].to_i }) if options.has_key?(:limit)
+        query_request.merge!({ :exclusive_start_key => options[:exclusive_start_key] }) if options[:exclusive_start_key]
+
+        @client.query(query_request)
+      end
+
+      def batch_get_item(keys, options={})
+        options[:return_consumed_capacity] ||= :none
+        options[:select] ||= []
+        options[:consistent_read] = false unless options[:consistent_read]
+
+        raise ArgumentError, "must include between 1 - 100 keys" if keys.size == 0 || keys.size > 100
+        keys_request = []
+        keys.each do |k|
+          key_request = {}
+          if @range_keys.present?
+            hash_value = k[:hash_value]
+          else
+            raise ArgumentError, "expected keys to be in the form of ['hash key here'] for table with no range keys" if hash_value.is_a?(Hash)
+            hash_value = k
+          end
+          raise ArgumentError, "every key must include a :hash_value" if hash_value.blank?
+          key_request[@hash_key[:attribute_name]] = { @hash_key[:attribute_type] => hash_value.to_s }
+          if @range_keys.present?
+            range_value = k[:range_value]
+            raise ArgumentError, "every key must include a :range_value" if range_value.blank?
+            range_key = @range_keys.find{|k| k[:primary_range_key] }
+            key_request[range_key[:attribute_name]] = { range_key[:attribute_type] => range_value.to_s }
+          end
+          keys_request << key_request
+        end
+
+        request_items_request = {}
+        request_items_request.merge!( :keys => keys_request )
+        request_items_request.merge!( :attributes_to_get => [options[:select]].flatten ) unless options[:select].blank?
+        request_items_request.merge!( :consistent_read => options[:consistent_read] ) if options[:consistent_read]
+        batch_get_item_request = {
+          :request_items => { (options[:table_name] || @table_schema[:table_name]) => request_items_request },
+          :return_consumed_capacity => RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]]
+        }
+        @client.batch_get_item(batch_get_item_request)
+      end
+
+      def write(hash_key_value, attributes, options={})
+        options[:return_consumed_capacity] ||= :none
+        options[:update_item] = false unless options[:update_item]
+
+        if options[:update_item]
+          # UpdateItem
+          key_request = {
+            @hash_key[:attribute_name] => {
+              @hash_key[:attribute_type] => hash_key_value.to_s
+            }
+          }
+          if @range_keys
+            range_key = @range_keys.find{|k| k[:primary_range_key]}
+            range_key_value = attributes[range_key[:attribute_name]]
+            raise ArgumentError, "range_key was not provided to the write command" if range_key_value.blank?
+            key_request.merge!({
+              range_key[:attribute_name] => {
+                range_key[:attribute_type] => range_key_value.to_s
+              }
+            })
+          end
+          attrs_to_update = {}
+          attributes.each_pair do |k,v|
+            next if @range_keys && k == range_key[:attribute_name]
+            attrs_to_update.merge!({
+              k => {
+                :value => attr_with_type(k,v).values.last,
+                :action => "PUT"
+              }
+            })
+          end
+          update_item_request = {
+            :table_name => options[:table_name] || @table_schema[:table_name],
+            :key => key_request,
+            :attribute_updates => attrs_to_update,
+            :return_consumed_capacity => RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]]
+          }
+          @client.update_item(update_item_request)
+        else
+          # PutItem
+          items = {}
+          attributes.each_pair do |k,v|
+            items.merge!(attr_with_type(k,v))
+          end
+          items.merge!(hash_key_item_param(hash_key_value))
+          put_item_request = {
+            :table_name => options[:table_name] || @table_schema[:table_name],
+            :item => items,
+            :return_consumed_capacity => RETURNED_CONSUMED_CAPACITY[options[:return_consumed_capacity]]
+          }
+          @client.put_item(put_item_request)
+        end
+      end
+
+      def delete_item(hash_key_value, options={})
+        key_request = {
+          @hash_key[:attribute_name] => {
+            @hash_key[:attribute_type] => hash_key_value.to_s
+          }
+        }
+        if @range_keys
+          range_key = @range_keys.find{|k| k[:primary_range_key]}
+          raise ArgumentError, "range_key was not provided to the delete_item command" if options[:range_value].blank?
+          key_request.merge!({
+            range_key[:attribute_name] => {
+              range_key[:attribute_type] => options[:range_value].to_s
+            }
+          })
+        end
+        delete_item_request = {
+          :table_name => options[:table_name] || @table_schema[:table_name],
+          :key => key_request
+        }
+        @client.delete_item(delete_item_request)
+      end
+
+      def 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
+        when value.respond_to?(:each)
+          indicator = nil
+          value.each do |v|
+            member_indicator = type_indicator(v)
+            raise ArgumentError, "nested collections" if member_indicator.to_s.size > 1
+            raise ArgumentError, "mixed types" if indicator and member_indicator != indicator
+            indicator = member_indicator
+          end
+          indicator ||= :s
+          :"#{indicator}s"
+        else
+          raise ArgumentError, "unsupported attribute type #{value.class}"
+        end
+      end
+
+      def create(options={})
+        if @client.list_tables[:table_names].include?(options[:table_name] || @table_schema[:table_name])
+          raise "Table #{options[:table_name] || @table_schema[:table_name]} already exists!"
+        end
+
+        @client.create_table(@table_schema.merge({
+          :table_name => options[:table_name] || @table_schema[:table_name]
+        }))
+
+        while (table_metadata = self.describe)[:table][:table_status] == "CREATING"
+          sleep 1
+        end
+        table_metadata
+      end
+
+      def describe
+        @client.describe_table(:table_name => @table_schema[:table_name])
+      end
+
+      def delete(options={})
+        return false unless @client.list_tables[:table_names].include?(options[:table_name] || @table_schema[:table_name])
+        @client.delete_table(:table_name => options[:table_name] || @table_schema[:table_name])
+        begin
+          while (table_metadata = self.describe) && table_metadata[:table][:table_status] == "DELETING"
+            sleep 1
+          end
+        rescue AWS::DynamoDB::Errors::ResourceNotFoundException => e
+          puts "Table deleted!"
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/toy/dynamo/version.rb

@@ -0,0 +1,5 @@
+module Toy
+  module Dynamo
+    VERSION = "0.0.1"
+  end
+end

data/lib/toy/dynamo.rb

@@ -0,0 +1,26 @@
+require "toy/dynamo/version"
+require "toy/dynamo/adapter"
+require "toy/dynamo/schema"
+require "toy/dynamo/table"
+require "toy/dynamo/querying"
+require "toy/dynamo/response"
+require "toy/dynamo/persistence"
+# Override 'write_attribute' for hash_key == id
+require "toy/dynamo/attributes"
+require "toy/dynamo/extensions/array"
+require "toy/dynamo/extensions/boolean"
+require "toy/dynamo/extensions/date"
+require "toy/dynamo/extensions/hash"
+require "toy/dynamo/extensions/set"
+require "toy/dynamo/extensions/time"
+require "toy/dynamo/extensions/symbol"
+
+module Toy
+  module Dynamo
+    extend ActiveSupport::Concern
+    include Toy::Store
+
+    include Schema
+    include Querying
+  end
+end

data/toy-dynamo.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'toy/dynamo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "toy-dynamo"
+  spec.version       = Toy::Dynamo::VERSION
+  spec.authors       = ["Cary Dunn"]
+  spec.email         = ["cary.dunn@gmail.com"]
+  spec.description   = %q{DynamoDB ORM - extension to toystore}
+  spec.summary       = %q{DynamoDB ORM - extension to toystore}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'adapter', '~> 0.7.0'
+  spec.add_dependency 'aws-sdk', '~> 1.9'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: toy-dynamo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cary Dunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: DynamoDB ORM - extension to toystore
+email:
+- cary.dunn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/toy/dynamo.rb
+- lib/toy/dynamo/adapter.rb
+- lib/toy/dynamo/attributes.rb
+- lib/toy/dynamo/extensions/array.rb
+- lib/toy/dynamo/extensions/boolean.rb
+- lib/toy/dynamo/extensions/date.rb
+- lib/toy/dynamo/extensions/hash.rb
+- lib/toy/dynamo/extensions/set.rb
+- lib/toy/dynamo/extensions/symbol.rb
+- lib/toy/dynamo/extensions/time.rb
+- lib/toy/dynamo/persistence.rb
+- lib/toy/dynamo/querying.rb
+- lib/toy/dynamo/response.rb
+- lib/toy/dynamo/schema.rb
+- lib/toy/dynamo/table.rb
+- lib/toy/dynamo/version.rb
+- toy-dynamo.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: DynamoDB ORM - extension to toystore
+test_files: []