lotus-dynamodb 0.1.0

data/lib/lotus/model/adapters/dynamodb/coercer.rb

@@ -0,0 +1,211 @@
+require 'lotus/utils/kernel'
+require 'multi_json'
+
+module Lotus
+  module Model
+    module Adapters
+      module Dynamodb
+        # Translates values from/to the database with the corresponding Ruby type.
+        #
+        # @api private
+        # @since 0.1.0
+        class Coercer < Lotus::Model::Mapping::Coercer
+          SKIPPED_KLASSES = [Float, Integer, Set, String]
+          SUPPORTED_KLASSES = [AWS::DynamoDB::Binary, Array, Boolean, Date, DateTime, Hash, Time]
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_aws_dynamodb_binary(value)
+            return value if value.nil? || value.is_a?(AWS::DynamoDB::Binary)
+            AWS::DynamoDB::Binary.new(value)
+          end
+
+          alias_method :to_aws_dynamodb_binary, :from_aws_dynamodb_binary
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_array(value)
+            _serialize(value)
+          end
+
+          # Converts value from DynamoDB record value to given type.
+          #
+          # @api private
+          # @since 0.1.0
+          def to_array(value)
+            _deserialize(value)
+          end
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_boolean(value)
+            value ? 1 : 0
+          end
+
+          # Converts value from DynamoDB record value to given type.
+          #
+          # @api private
+          # @since 0.1.0
+          def to_boolean(value)
+            value.to_i == 1
+          end
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_date(value)
+            value.to_time.to_i
+          end
+
+          # Converts value from DynamoDB record value to given type.
+          #
+          # @api private
+          # @since 0.1.0
+          def to_date(value)
+            Time.at(value.to_i).to_date
+          end
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_datetime(value)
+            value.to_time.to_f
+          end
+
+          # Converts value from DynamoDB record value to given type.
+          #
+          # @api private
+          # @since 0.1.0
+          def to_datetime(value)
+            Time.at(value.to_f).to_datetime
+          end
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_hash(value)
+            _serialize(value)
+          end
+
+          # Converts value from DynamoDB record value to given type.
+          #
+          # @api private
+          # @since 0.1.0
+          def to_hash(value)
+            _deserialize(value)
+          end
+
+          # Converts value from given type to DynamoDB record value.
+          #
+          # @api private
+          # @since 0.1.0
+          def from_time(value)
+            value.to_f
+          end
+
+          # Converts value from DynamoDB record value to given type.
+          #
+          # @api private
+          # @since 0.1.0
+          def to_time(value)
+            Time.at(value.to_f)
+          end
+
+          private
+          # Compile itself for performance boost.
+          #
+          # @api private
+          # @since 0.1.0
+          def _compile!
+            instance_eval(SKIPPED_KLASSES.map do |klass|
+              %{
+              def from_#{_method_name(klass)}(value)
+                value
+              end
+
+              def to_#{_method_name(klass)}(value)
+                value
+              end
+              }
+            end.join("\n"))
+
+            code = @collection.attributes.map do |_,(klass,mapped)|
+              %{
+              def deserialize_#{ mapped }(value)
+                #{kernel_wrap(klass) { "from_#{_method_name(klass)}(value)" }}
+              end
+
+              def serialize_#{ mapped }(value)
+                from_#{_method_name(klass)}(value)
+              end
+              }
+            end.join("\n")
+
+            instance_eval %{
+              def to_record(entity)
+                if entity.id
+                  Hash[*[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{mapped},from_#{_method_name(klass)}(entity.#{name})"}.join(',') }]]
+                else
+                  Hash[*[#{ @collection.attributes.reject{|name,_| name == @collection.identity }.map{|name,(klass,mapped)| ":#{mapped},from_#{_method_name(klass)}(entity.#{name})"}.join(',') }]]
+                end
+              end
+
+              def from_record(record)
+                #{ @collection.entity }.new(
+                  Hash[*[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{name},#{kernel_wrap(klass) { "to_#{_method_name(klass)}(record[:#{mapped}])" }}"}.join(',') }]]
+                )
+              end
+
+              #{ code }
+            }
+          end
+
+          # Wraps string in Lotus::Utils::Kernel call if needed.
+          #
+          # @api private
+          # @since 0.1.0
+          def kernel_wrap(klass)
+            if klass.to_s.include?("::")
+              yield
+            else
+              "Lotus::Utils::Kernel.#{klass}(#{yield})"
+            end
+          end
+
+          # Returns method name from klass.
+          #
+          # @api private
+          # @since 0.1.0
+          def _method_name(klass)
+            klass.to_s.downcase.gsub("::", "_")
+          end
+
+          # Serializes value to string.
+          #
+          # @api private
+          # @since 0.1.0
+          def _serialize(value)
+            MultiJson.dump(value)
+          end
+
+          # Deserializes value from string.
+          #
+          # @api private
+          # @since 0.1.0
+          def _deserialize(value)
+            MultiJson.load(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/adapters/dynamodb/collection.rb

@@ -0,0 +1,321 @@
+require 'securerandom'
+require 'aws-sdk'
+require 'lotus/utils/hash'
+
+module Lotus
+  module Model
+    module Adapters
+      module Dynamodb
+        # Acts like table, using AWS::DynamoDB::Client.
+        #
+        # @api private
+        # @since 0.1.0
+        class Collection
+          include AWS::DynamoDB::Types
+
+          # Response interface provides count and entities.
+          #
+          # @api private
+          # @since 0.1.0
+          class Response
+            attr_accessor :count, :entities
+
+            def initialize(count, entities = nil)
+              @count, @entities = count, entities
+            end
+          end
+
+          # @attr_reader name [String] the name of the collection (eg. `users`)
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :name
+
+          # @attr_reader identity [Symbol] the primary key of the collection
+          #   (eg. `:id`)
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :identity
+
+          # Initialize a collection.
+          #
+          # @param client [AWS::DynamoDB::Client] DynamoDB client
+          # @param coercer [Lotus::Model::Adapters::Dynamodb::Coercer]
+          # @param name [Symbol] the name of the collection (eg. `:users`)
+          # @param identity [Symbol] the primary key of the collection
+          #   (eg. `:id`).
+          #
+          # @api private
+          # @since 0.1.0
+          def initialize(client, coercer, name, identity)
+            @client, @coercer = client, coercer
+            @name, @identity = name.to_s, identity
+            @key_schema = {}
+          end
+
+          # Creates a record for the given entity and returns a primary key.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Command#create
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#put_item-instance_method
+          #
+          # @return the primary key of the just created record.
+          #
+          # @api private
+          # @since 0.1.0
+          def create(entity)
+            entity[identity] ||= SecureRandom.uuid
+
+            @client.put_item(
+              table_name: name,
+              item: serialize_item(entity),
+            )
+
+            entity[identity]
+          end
+
+          # Updates the record corresponding to the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Command#update
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#update_item-instance_method
+          #
+          # @api private
+          # @since 0.1.0
+          def update(entity)
+            @client.update_item(
+              table_name: name,
+              key: serialize_key(entity),
+              attribute_updates: serialize_attributes(entity),
+            )
+          end
+
+          # Deletes the record corresponding to the given entity.
+          #
+          # @param entity [Object] the entity to delete
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Command#delete
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#delete_item-instance_method
+          #
+          # @api private
+          # @since 0.1.0
+          def delete(entity)
+            @client.delete_item(
+              table_name: name,
+              key: serialize_key(entity),
+            )
+          end
+
+          # Returns an unique record from the given collection, with the given
+          # id.
+          #
+          # @param key [Array] the identity of the object
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Command#get
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#get_item-instance_method
+          #
+          # @return [Hash] the serialized record
+          #
+          # @api private
+          # @since 0.1.0
+          def get(key)
+            return if key.any? { |v| v.to_s == "" }
+            return if key.count != key_schema.count
+
+            response = @client.get_item(
+              table_name: name,
+              key: serialize_key(key),
+            )
+
+            deserialize_item(response[:item]) if response[:item]
+          end
+
+          # Performs DynamoDB query operation.
+          #
+          # @param options [Hash] AWS::DynamoDB::Client options
+          #
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#query-instance_method
+          #
+          # @return [Array<Hash>] the serialized entities
+          #
+          # @api private
+          # @since 0.1.0
+          def query(options = {})
+            response = @client.query(options.merge(table_name: name))
+            deserialize_response(response)
+          end
+
+          # Performs DynamoDB scan operation.
+          #
+          # @param options [Hash] AWS::DynamoDB::Client options
+          #
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#scan-instance_method
+          #
+          # @return [Array<Hash>] the serialized entities
+          #
+          # @api private
+          # @since 0.1.0
+          def scan(options = {})
+            response = @client.scan(options.merge(table_name: name))
+            deserialize_response(response)
+          end
+
+          # Fetches DynamoDB table schema.
+          #
+          # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#describe_table-instance_method
+          #
+          # @return [Hash] table schema definition
+          #
+          # @api private
+          # @since 0.1.0
+          def schema
+            @schema ||= @client.describe_table(table_name: name).fetch(:table)
+          end
+
+          # Maps table key schema to hash with attribute name as key and key
+          # type as value.
+          #
+          # @param index [String] index to check (defaults to table itself)
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#schema
+          #
+          # @return [Hash] key schema definition
+          #
+          # @api private
+          # @since 0.1.0
+          def key_schema(index = nil)
+            return @key_schema[index] if @key_schema[index]
+
+            current_schema = if index
+              everything = Array(schema[:local_secondary_indexes]) +
+                           Array(schema[:global_secondary_indexes])
+              indexes = Hash[everything.map { |i| [i[:index_name], i] }]
+              indexes[index][:key_schema]
+            else
+              schema[:key_schema]
+            end
+
+            @key_schema[index] ||= Hash[current_schema.to_a.map do |key|
+              [key[:attribute_name].to_sym, key[:key_type]]
+            end]
+          end
+
+          # Checks if given column is in key schema or not.
+          #
+          # @param column [String] column to check
+          # @param index [String] index to check (defaults to table itself)
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#key_schema
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          # @since 0.1.0
+          def key?(column, index = nil)
+            key_schema(index).has_key?(column)
+          end
+
+          # Coerce and format attribute value to match DynamoDB type.
+          #
+          # @param column [String] the attribute column
+          # @param value [Object] the attribute value
+          #
+          # @see AWS::DynamoDB::Types
+          #
+          # @return [Hash] the formatted attribute
+          #
+          # @api private
+          # @since 0.1.0
+          def format_attribute(column, value)
+            value = @coercer.public_send(:"serialize_#{ column }", value)
+            format_attribute_value(value)
+          end
+
+          # Serialize given record to have proper attributes for 'item' query.
+          #
+          # @param record [Hash] the serialized record
+          #
+          # @see AWS::DynamoDB::Types
+          #
+          # @return [Hash] the serialized item
+          #
+          # @api private
+          # @since 0.1.0
+          def serialize_item(record)
+            Hash[record.map { |k, v| [k.to_s, format_attribute_value(v)] }]
+          end
+
+          # Serialize given record or primary key to have proper attributes
+          # for 'key' query.
+          #
+          # @param record [Hash,Array] the serialized record or primary key
+          #
+          # @see AWS::DynamoDB::Types
+          #
+          # @return [Hash] the serialized key
+          #
+          # @api private
+          # @since 0.1.0
+          def serialize_key(record)
+            Hash[key_schema.keys.each_with_index.map do |k, idx|
+              v = record.is_a?(Hash) ? record[k] : record[idx]
+              [k.to_s, format_attribute(k, v)]
+            end]
+          end
+
+          # Serialize given entity to exclude key schema attributes.
+          #
+          # @param entity [Hash] the entity
+          #
+          # @see AWS::DynamoDB::Types
+          #
+          # @return [Hash] the serialized attributes
+          #
+          # @api private
+          # @since 0.1.0
+          def serialize_attributes(entity)
+            keys = key_schema.keys
+            Hash[entity.reject { |k, _| keys.include?(k) }.map do |k, v|
+              [k.to_s, { value: format_attribute_value(v), action: "PUT" }]
+            end]
+          end
+
+          # Deserialize DynamoDB scan/query response.
+          #
+          # @param response [Hash] the serialized response
+          #
+          # @return [Hash] the deserialized response
+          #
+          # @api private
+          # @since 0.1.0
+          def deserialize_response(response)
+            result = Response.new(response[:count])
+
+            result.entities = response[:member].map do |item|
+              deserialize_item(item)
+            end if response[:member]
+
+            result
+          end
+
+          # Deserialize item from DynamoDB response.
+          #
+          # @param item [Hash] the serialized item
+          #
+          # @see AWS::DynamoDB::Types
+          #
+          # @return [Hash] the deserialized record
+          #
+          # @api private
+          # @since 0.1.0
+          def deserialize_item(record)
+            Lotus::Utils::Hash.new(values_from_response_hash(record)).symbolize!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/adapters/dynamodb/command.rb

@@ -0,0 +1,117 @@
+module Lotus
+  module Model
+    module Adapters
+      module Dynamodb
+        # Execute a command for the given collection.
+        #
+        # @see Lotus::Model::Adapters::Dynamodb::Collection
+        # @see Lotus::Model::Mapping::Collection
+        #
+        # @api private
+        # @since 0.1.0
+        class Command
+          # Initialize a command.
+          #
+          # @param dataset [Lotus::Model::Adapters::Dynamodb::Collection]
+          # @param collection [Lotus::Model::Mapping::Collection]
+          #
+          # @return [Lotus::Model::Adapters::Dynamodb::Command]
+          #
+          # @api private
+          # @since 0.1.0
+          def initialize(dataset, collection)
+            @dataset, @collection = dataset, collection
+          end
+
+          # Creates a record for the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#create
+          #
+          # @return the primary key of the just created record.
+          #
+          # @api private
+          # @since 0.1.0
+          def create(entity)
+            @dataset.create(
+              _serialize(entity)
+            )
+          end
+
+          # Updates the corresponding record for the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#update
+          #
+          # @api private
+          # @since 0.1.0
+          def update(entity)
+            @dataset.update(
+              _serialize(entity)
+            )
+          end
+
+          # Deletes the corresponding record for the given entity.
+          #
+          # @param entity [Object] the entity to delete
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#delete
+          #
+          # @api private
+          # @since 0.1.0
+          def delete(entity)
+            @dataset.delete(
+              _serialize(entity)
+            )
+          end
+
+          # Returns an unique record from the given collection, with the given
+          # id.
+          #
+          # @param key [Array] the identity of the object
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#get
+          #
+          # @return [Object] the entity
+          #
+          # @api private
+          # @since 0.1.0
+          def get(key)
+            @collection.deserialize(
+              [@dataset.get(key)].compact
+            ).first
+          end
+
+          # Deletes all the records from the table.
+          #
+          # @see Lotus::Model::Adapters::Dynamodb::Collection#scan
+          # @see Lotus::Model::Mapping::Collection
+          #
+          # @api private
+          # @since 0.1.0
+          def clear
+            @collection.deserialize(@dataset.scan.entities).each do |entity|
+              delete(entity)
+            end
+          end
+
+          private
+          # Serialize the given entity before to persist in the database.
+          #
+          # @param entity [Object] the entity
+          #
+          # @return [Hash] the serialized entity
+          #
+          # @api private
+          # @since 0.1.0
+          def _serialize(entity)
+            serialized = @collection.serialize(entity)
+            serialized.delete_if { |_, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end