dynamodb_framework 0.1.4 → 1.0.0

data/README.md

@@ -25,7 +25,7 @@ To create or modify a DynamoDb instance you first need to create a migration scr
 
 **Example**
 
-    class CreateEventTrackingTableScript < MigrationScript
+    class CreateEventTrackingTableScript < DynamoDbFramework::MigrationScript
 
 		def initialize
 			#set the timestamp for when this script was created
@@ -34,9 +34,9 @@ To create or modify a DynamoDb instance you first need to create a migration scr
 
 		def apply
 			#create an instance of the table manager
-			manager = DynamoDbTableManager.new
+			manager = DynamoDbFramework::TableManager.new
 			#create an attribute builder
-			builder = DynamoDbAttributesBuilder.new
+			builder = DynamoDbFramework::AttributesBuilder.new
 
 			#set the hash key attribute
 			builder.add(:type, :S)			
@@ -47,7 +47,7 @@ To create or modify a DynamoDb instance you first need to create a migration scr
 		def undo
 		
 			#create an instance of the table manager
-			manager = DynamoDbTableManager.new
+			manager = DynamoDbFramework::TableManager.new
 
 			#drop the table
 			manager.drop('event_tracking')
@@ -75,7 +75,7 @@ This method is called to connect the manager to the DynamoDb instance. If the mi
 
 **Example**
 
-    manager = DynamoDbMigrationManager.new
+    manager = DynamoDbFramework::MigrationManager.new
     manager.connect
 
 ### #apply
@@ -92,7 +92,7 @@ This method is called to rollback the last migration script that was executed ag
     #rollback the last migration script
     manager.rollback
 
-# DynamoDbTableManager
+# DynamoDbFramework::TableManager
 
 This manager object provides the following methods for managing tables within a DynamoDb instance.
 
@@ -103,7 +103,7 @@ This method is called to create a table within DynamoDb.
 **Params**
 
  - **table_name** [String] [Required] This is used to specify the name of the table to create. (Must be unique within the DynamoDb instance).
- - **attributes** [Hash] [Required] This is used to specify the attributes used by the keys and indexes. (Use the DynamoDbAttributesBuilder to create attributes)
+ - **attributes** [Hash] [Required] This is used to specify the attributes used by the keys and indexes. (Use the DynamoDbFramework::AttributesBuilder to create attributes)
  - **partition_key** [Symbol] [Required] This is the document attribute that will be used as the partition key of this table.
  - **range_key** [Symbol / nil] [Optional] This is the document attribute that will be used as the range key for this table.
  - **read_capacity** [Number] [Default=20] This is the read throughput required for this table.
@@ -115,7 +115,7 @@ This method is called to create a table within DynamoDb.
 Table with partition key, no range key and no indexes:
 
     #create an attribute builder
-	builder = DynamoDbAttributesBuilder.new
+	builder = DynamoDbFramework::AttributesBuilder.new
 
 	#set the partition key attribute
 	builder.add(:type, :S)		
@@ -126,7 +126,7 @@ Table with partition key, no range key and no indexes:
 Table with partition key, range key and no indexes:
 
     #create an attribute builder
-	builder = DynamoDbAttributesBuilder.new
+	builder = DynamoDbFramework::AttributesBuilder.new
 
 	#set the partition key attribute
 	builder.add(:type, :S)	
@@ -139,7 +139,7 @@ Table with partition key, range key and no indexes:
 Table with a global index:
 
     #create an attribute builder
-	builder = DynamoDbAttributesBuilder.new
+	builder = DynamoDbFramework::AttributesBuilder.new
 
 	#set the partition key attribute
 	builder.add(:id, :S)		
@@ -181,13 +181,13 @@ This method is called to add an index to an existing table.
 **Params**
 
  - **table_name** [String] [Required] This is the name of the index. (Must be unique within the scope of the table)
- - **attributes** [Hash] [Required] This is the document attributes used by the table keys and index keys. (Use the DynamoDbAttributesBuilder to create the attributes hash.)
+ - **attributes** [Hash] [Required] This is the document attributes used by the table keys and index keys. (Use the DynamoDbFramework::AttributesBuilder to create the attributes hash.)
  - **global_index** [Hash] [Required] This is the global index to add to the table. (Use the ***#create_global_index*** method to create the global index hash.)
  
 **Example**
 
 	#build the attributes hash
-	builder = DynamoDbAttributesBuilder.new
+	builder = DynamoDbFramework::AttributesBuilder.new
 	#add the attribute for the tables partition key & range key (if range key required)
 	builder.add(:id, :S)
 	#add the attributes for the index partition key and range key (if required)
@@ -237,7 +237,7 @@ This method is called to check if an index exists on a table within the database
     => true
 
 
-# DynamoDbRepository
+# DynamoDbFramework::Repository
 
 This is a base repository that exposes core functionality for interacting with a DynamoDb table. It is intended to be wrapped inside of a table specific repository, and is only provided to give a common way of interacting with a DynamoDb table.
 

data/dynamodb_framework.gemspec

@@ -5,7 +5,7 @@ require 'dynamodb_framework/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "dynamodb_framework"
-  spec.version       = DynamodbFramework::VERSION
+  spec.version       = DynamoDbFramework::VERSION
   spec.authors       = ["vaughanbrittonsage"]
   spec.email         = ["vaughanbritton@gmail.com"]
 

data/lib/dynamodb_framework.rb

@@ -1,7 +1,11 @@
-require "dynamodb_framework/version"
-require "dynamodb_framework/dynamodb_attributes_builder"
-require "dynamodb_framework/dynamodb_store"
-require "dynamodb_framework/dynamodb_table_manager"
-require "dynamodb_framework/dynamodb_repository"
-require "dynamodb_framework/dynamodb_migration_manager"
-require "dynamodb_framework/dynamodb_migration_script"
+require_relative 'dynamodb_framework/version'
+require_relative 'dynamodb_framework/dynamodb_attributes_builder'
+require_relative 'dynamodb_framework/dynamodb_store'
+require_relative 'dynamodb_framework/dynamodb_table_manager'
+require_relative 'dynamodb_framework/dynamodb_repository'
+require_relative 'dynamodb_framework/dynamodb_migration_manager'
+require_relative 'dynamodb_framework/dynamodb_migration_script'
+require_relative 'dynamodb_framework/dynamodb_logger'
+
+require 'date'
+

data/lib/dynamodb_framework/dynamodb_attributes_builder.rb

@@ -1,20 +1,64 @@
-class DynamoDbAttributesBuilder
-  attr_reader :attributes
+module DynamoDbFramework
+  class AttributesBuilder
+    attr_reader :attributes
 
-  def initialize
-    @attributes = []
-  end
+    def initialize
+      @attributes = []
+    end
+
+    def add_from_args(name, type, key = nil)
+      type_symbol = :S
+      if type == 'number' || type == :N || type == :number
+        type_symbol = :N
+      elsif type == 'binary' || type == :B || type == :binary
+        type_symbol = :B
+      elsif type == 'bool' || type == 'boolean' || type == :BOOL || type == :bool || type == :boolean
+        type_symbol = :BOOL
+      end
+
+      if key == 'hash' || key == :hash
+        key = :hash
+      elsif key == 'range' || key == :range
+        key = :range
+      else
+        key = nil
+      end
 
-  def add(name, type)
-    type_symbol = :S
-    if type == 'number' || type == :N
-      type_symbol = :N
-    elsif type == 'binary' || type == :B
-      type_symbol = :B
-    elsif type == 'bool' || type == 'boolean' || type == :BOOL
-      type_symbol = :BOOL
+      @attributes.push({ :name => name, :type => type_symbol, :key => key })
     end
-    @attributes.push({ :name => name, :type => type_symbol })
-  end
 
-end
+    def add_from_hash(options)
+      type_symbol = :S
+      if options[:type] == 'number' || options[:type] == :N || options[:type] == :number
+        type_symbol = :N
+      elsif options[:type] == 'binary' || options[:type] == :B || options[:type] == :binary
+        type_symbol = :B
+      elsif options[:type] == 'bool' || options[:type] == 'boolean' || options[:type] == :BOOL || options[:type] == :bool || options[:type] == :boolean
+        type_symbol = :BOOL
+      end
+
+      if options[:key] == 'hash' || options[:key] == :hash
+        key = :hash
+      elsif options[:key] == 'range' || options[:key] == :range
+        key = :range
+      else
+        key = nil
+      end
+
+      @attributes.push({ :name => options[:name], :type => type_symbol, :key => key })
+    end
+
+    def add(*options)
+
+      if options.length == 1 && options[0].is_a?(Hash)
+        add_from_hash(options[0])
+      elsif options.length == 3
+        add_from_args(options[0], options[1], options[2])
+      else
+        add_from_args(options[0], options[1])
+      end
+
+    end
+
+  end
+end

data/lib/dynamodb_framework/dynamodb_logger.rb

@@ -0,0 +1,7 @@
+require 'logger'
+
+module DynamoDbFramework
+
+  LOGGER = Logger.new(STDOUT)
+
+end

data/lib/dynamodb_framework/dynamodb_migration_manager.rb

@@ -1,89 +1,91 @@
-class DynamoDbMigrationManager
+module DynamoDbFramework
+  class MigrationManager
 
-  attr_reader :dynamodb_table_manager
-  attr_reader :dynamodb_repository
+    attr_reader :dynamodb_table_manager
+    attr_reader :dynamodb_repository
 
-  def initialize
-    @dynamodb_repository = DynamoDbRepository.new
-    @dynamodb_table_manager = DynamoDbTableManager.new
-  end
-
-  def connect
+    def initialize(store)
+      @dynamodb_repository = DynamoDbFramework::Repository.new(store)
+      @dynamodb_table_manager = DynamoDbFramework::TableManager.new(store)
+    end
 
-    puts 'Connecting to DynamoDb instance.....'
+    def connect
 
-    migration_table_name = 'dynamodb_migrations'
+      DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Connecting to DynamoDb instance'
 
-    #check if migration table exists
-    if !@dynamodb_table_manager.exists?(migration_table_name)
-      #migration table not found so create it
-      builder = DynamoDbAttributesBuilder.new
-      builder.add(:timestamp, :S)
-      @dynamodb_table_manager.create(migration_table_name, builder.attributes, :timestamp)
-    end
+      migration_table_name = 'dynamodb_framework_migrations'
 
-    #set the table name for the repository
-    @dynamodb_repository.table_name = migration_table_name
+      #check if migration table exists
+      if !@dynamodb_table_manager.exists?(migration_table_name)
+        #migration table not found so create it
+        builder = DynamoDbFramework::AttributesBuilder.new
+        builder.add(:timestamp, :S)
+        @dynamodb_table_manager.create(migration_table_name, builder.attributes, :timestamp)
+      end
 
-    puts 'Connected.'
+      #set the table name for the repository
+      @dynamodb_repository.table_name = migration_table_name
 
-  end
+      DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Connected.'
 
-  def get_executed_scripts
-    scripts = @dynamodb_repository.all()
-    if scripts.length > 0
-      return scripts.sort { |a,b| b['timestamp'] <=> a['timestamp'] }.map { |i| i['timestamp'] }
     end
 
-    return nil
-  end
+    def get_executed_scripts
+      scripts = @dynamodb_repository.all()
+      if scripts.length > 0
+        return scripts.sort { |a,b| b['timestamp'] <=> a['timestamp'] }.map { |i| i['timestamp'] }
+      end
 
-  def apply
+      return nil
+    end
 
-    puts 'Applying migration scripts.....'
+    def apply
 
-    executed_scripts = get_executed_scripts()
+      DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Applying migration scripts'
 
-    scripts = []
-    MigrationScript.descendants.each do |ms|
-      script = ms.new
-      scripts.push(script)
-    end
+      executed_scripts = get_executed_scripts()
 
-    scripts.sort { |a,b| a.timestamp <=> b.timestamp }.each do |script|
-      if executed_scripts == nil || !executed_scripts.include?(script.timestamp)
-        puts 'Applying script: ' + script.timestamp + '.....'
-        script.apply
-        @dynamodb_repository.put({ :timestamp => script.timestamp })
+      scripts = []
+      DynamoDbFramework::MigrationScript.descendants.each do |ms|
+        script = ms.new
+        scripts.push(script)
       end
-    end
 
-    puts 'Migration scripts applied.'
+      scripts.sort { |a,b| a.timestamp <=> b.timestamp }.each do |script|
+        if executed_scripts == nil || !executed_scripts.include?(script.timestamp)
+          DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Applying script: ' + script.timestamp + '.....'
+          script.apply
+          @dynamodb_repository.put({ :timestamp => script.timestamp })
+        end
+      end
 
-  end
+      DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Migration scripts applied.'
 
-  def rollback
+    end
 
-    puts 'Rolling back last migration script.....'
+    def rollback
 
-    executed_scripts = get_executed_scripts()
+      DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Rolling back started.'
 
-    scripts = []
-    MigrationScript.descendants.each do |ms|
-      script = ms.new
-      scripts.push(script)
-    end
+      executed_scripts = get_executed_scripts()
 
-    scripts.sort { |a,b| a.timestamp <=> b.timestamp }.each do |script|
-      if executed_scripts != nil && executed_scripts.length > 0 && executed_scripts.include?(script.timestamp)
-        script.undo
-        @dynamodb_repository.delete({ :timestamp => script.timestamp })
-        return
+      scripts = []
+      DynamoDbFramework::MigrationScript.descendants.each do |ms|
+        script = ms.new
+        scripts.push(script)
       end
-    end
 
-    puts 'Completed.'
+      scripts.sort { |a,b| a.timestamp <=> b.timestamp }.each do |script|
+        if executed_scripts != nil && executed_scripts.length > 0 && executed_scripts.include?(script.timestamp)
+          script.undo
+          @dynamodb_repository.delete({ :timestamp => script.timestamp })
+          return
+        end
+      end
 
-  end
+      DynamoDbFramework::LOGGER.info '[DynamoDbFramework] - Rollback complete.'
 
-end
+    end
+
+  end
+end

data/lib/dynamodb_framework/dynamodb_migration_script.rb

@@ -1,16 +1,17 @@
-class MigrationScript
-  attr_accessor :timestamp
+module DynamoDbFramework
+  class MigrationScript
+    attr_accessor :timestamp
 
-  def apply
-    raise 'Not implemented.'
-  end
+    def apply
+      raise 'Not implemented.'
+    end
 
-  def undo
-    raise 'Not implemented.'
-  end
+    def undo
+      raise 'Not implemented.'
+    end
 
-  def self.descendants
-    ObjectSpace.each_object(Class).select { |klass| klass < self }
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
   end
-
-end
+end

data/lib/dynamodb_framework/dynamodb_repository.rb

@@ -1,193 +1,220 @@
-class DynamoDbRepository
+require 'date'
 
-  attr_reader :dynamodb
-  attr_accessor :table_name
+module DynamoDbFramework
+  class Repository
 
-  def initialize
-    @dynamodb = DynamoDbStore.new
-  end
+    attr_reader :dynamodb
+    attr_accessor :table_name
 
-  def put(item)
+    def initialize(store)
+      @dynamodb = store
+    end
 
-    json_string = item.to_json
-    json_obj = JSON.load(json_string)
+    def put(item)
 
-    params =
-        {
-            table_name: @table_name,
-            item: json_obj
-        }
+      hash = to_hash(item)
 
-    dynamodb.client.put_item(params)
+      params =
+          {
+              table_name: @table_name,
+              item: hash
+          }
 
-  end
+      dynamodb.client.put_item(params)
 
-  def delete(keys)
+      return true
 
-    params =
-        {
-            table_name: @table_name,
-            key: keys
-        }
+    end
 
-    dynamodb.client.delete_item(params)
+    def delete(keys)
 
-  end
+      params =
+          {
+              table_name: @table_name,
+              key: keys
+          }
 
-  def get_by_key(partition_key, partition_value, range_key = nil, range_value = nil)
+      dynamodb.client.delete_item(params)
 
-    key = {}
-    key[partition_key] = partition_value
-    if(range_key != nil)
-      key[range_key] = range_value
-    end
+      return true
 
-    params = {
-        table_name: table_name,
-        key: key
-    }
+    end
 
-    result = dynamodb.client.get_item(params)
-    return map(result.item)
+    def get_by_key(partition_key, partition_value, range_key = nil, range_value = nil)
 
-  end
+      key = {}
+      key[partition_key] = partition_value
+      if(range_key != nil)
+        key[range_key] = range_value
+      end
 
-  def all
+      params = {
+          table_name: table_name,
+          key: key
+      }
 
-    result = dynamodb.client.scan({
-                                      :table_name => table_name
-                                  })
+      result = dynamodb.client.get_item(params)
+      return result.item
 
-    output = []
-    result.items.each do |item|
-      output.push(map(item))
     end
 
-    return output
+    def all
 
-  end
+      result = dynamodb.client.scan({
+                                        :table_name => @table_name
+                                    })
 
-  def scan(expression, expression_params, limit = nil, count = false)
+      output = []
+      result.items.each do |item|
+        output.push(item)
+      end
 
-    params = {
-        :table_name => table_name
-    }
+      return output
 
-    if expression != nil
-      params[:filter_expression] = expression
     end
 
-    if expression_params != nil
+    def scan(expression, expression_params, limit = nil, count = false)
 
-      params[:expression_attribute_names] = {}
-      params[:expression_attribute_values] = {}
+      params = {
+          :table_name => table_name
+      }
 
-      expression_params.each do |key, value|
-        if key.starts_with?('#')
-          params[:expression_attribute_names][key] = value
-        elsif key.starts_with?(':')
-          params[:expression_attribute_values][key] = value
-        end
+      if expression != nil
+        params[:filter_expression] = expression
       end
 
-    end
+      if expression_params != nil
 
-    if limit != nil
-      params[:limit] = limit
-    end
+        params[:expression_attribute_names] = {}
+        params[:expression_attribute_values] = {}
 
-    if count
-      params[:select] = 'COUNT'
-    else
-      params[:select] = 'ALL_ATTRIBUTES'
-    end
+        expression_params.each do |key, value|
+          if key[0] == '#'
+            params[:expression_attribute_names][key] = value
+          elsif key[0] == ':'
+            params[:expression_attribute_values][key] = value
+          end
+        end
 
-    result = dynamodb.client.scan(params)
+      end
 
-    if count
-      return result.count
-    else
-      output = []
-      result.items.each do |item|
-        output.push(map(item))
+      if limit != nil
+        params[:limit] = limit
       end
 
-      return output
-    end
+      if count
+        params[:select] = 'COUNT'
+      else
+        params[:select] = 'ALL_ATTRIBUTES'
+      end
 
-  end
+      result = dynamodb.client.scan(params)
 
-  def query(partition_key_name, partition_key_value, range_key_name = nil, range_key_value = nil, expression = nil, expression_params = nil, index_name = nil, limit = nil, count = false)
+      if count
+        return result.count
+      else
+        output = []
+        result.items.each do |item|
+          output.push(item)
+        end
 
-    params = {
-        table_name: table_name
-    }
+        return output
+      end
 
-    if expression != nil
-      params[:filter_expression] = expression
     end
 
-    if index_name != nil
-      params[:index_name] = index_name
-    end
+    def query(partition_key_name, partition_key_value, range_key_name = nil, range_key_value = nil, expression = nil, expression_params = nil, index_name = nil, limit = nil, count = false)
 
-    if range_key_name != nil
-      params[:key_condition_expression] = '#partition_key = :partition_key and #range_key = :range_key'
-      params[:expression_attribute_names] = { '#partition_key' => partition_key_name, '#range_key' => range_key_name }
-      params[:expression_attribute_values] = { ':partition_key' => partition_key_value, ':range_key' => range_key_value }
-    else
-      params[:key_condition_expression] = '#partition_key = :partition_key'
-      params[:expression_attribute_names] = { '#partition_key' => partition_key_name }
-      params[:expression_attribute_values] = { ':partition_key' => partition_key_value }
-    end
+      params = {
+          table_name: table_name
+      }
+
+      if expression != nil
+        params[:filter_expression] = expression
+      end
 
-    if expression_params != nil
+      if index_name != nil
+        params[:index_name] = index_name
+      end
+
+      if range_key_name != nil
+        params[:key_condition_expression] = '#partition_key = :partition_key and #range_key = :range_key'
+        params[:expression_attribute_names] = { '#partition_key' => partition_key_name, '#range_key' => range_key_name }
+        params[:expression_attribute_values] = { ':partition_key' => partition_key_value, ':range_key' => range_key_value }
+      else
+        params[:key_condition_expression] = '#partition_key = :partition_key'
+        params[:expression_attribute_names] = { '#partition_key' => partition_key_name }
+        params[:expression_attribute_values] = { ':partition_key' => partition_key_value }
+      end
 
-      expression_params.each do |key, value|
-        if key.starts_with?('#')
-          params[:expression_attribute_names][key] = value
-        elsif key.starts_with?(':')
-          params[:expression_attribute_values][key] = value
+      if expression_params != nil
+        expression_params.each do |key, value|
+          if key[0] == '#'
+            params[:expression_attribute_names][key] = value
+          elsif key[0] == ':'
+            params[:expression_attribute_values][key] = value
+          end
         end
+
       end
 
-    end
+      if limit != nil
+        params[:limit] = limit
+      end
 
-    if limit != nil
-      params[:limit] = limit
-    end
+      if count
+        params[:select] = 'COUNT'
+      else
+        params[:select] = 'ALL_ATTRIBUTES'
+      end
 
-    if count
-      params[:select] = 'COUNT'
-    else
-      params[:select] = 'ALL_ATTRIBUTES'
-    end
+      result = dynamodb.client.query(params)
 
-    result = dynamodb.client.query(params)
+      if count
+        return result.count
+      else
+        output = []
+        result.items.each do |item|
+          output.push(item)
+        end
 
-    if count
-      return result.count
-    else
-      output = []
-      result.items.each do |item|
-        output.push(map(item))
+        return output
       end
 
-      return output
     end
 
-  end
+    private
 
-  def map(item)
-    return item
-  end
+    def to_hashb(obj)
+      hash = {}
+      obj.instance_variables.each {|var| hash[var.to_s.delete("@")] = obj.instance_variable_get(var) }
+      hash
+    end
+
+    STANDARD_TYPES = [String, Numeric, Fixnum, Integer, Float, nil, Time, Date, DateTime].freeze
 
-end
+    def is_standard_type?(obj)
+      return STANDARD_TYPES.detect { |type| obj.is_a?(type) } != nil
+    end
+
+    def to_hash(obj)
+      if obj.is_a?(Hash)
+        return obj
+      end
+
+      hash = {}
+      obj.instance_variables.each do |var|
+        value = obj.instance_variable_get(var)
+        if value.is_a?(Array)
+          hash[var.to_s.delete("@")] = value.collect { |i| to_hash(i) }
+        elsif !is_standard_type?(value)
+          hash[var.to_s.delete("@")] = to_hash(value)
+        else
+          hash[var.to_s.delete("@")] = value
+        end
+      end
+      hash
+    end
 
-class ::Hash
-  def method_missing(name)
-    return self[name] if key? name
-    self.each { |k,v| return v if k.to_s.to_sym == name }
-    super.method_missing name
   end
 end