dynamodb_framework 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 318aa80e8817e3654c1b398b6ae5610c6306ed1f
-  data.tar.gz: 23223e4bdf089ff9257a0501c01ae8c1eaa39538
+  metadata.gz: 9c4bf2ce79200a61fab5ff066efb0de60535fdd8
+  data.tar.gz: 5c338f2559cadf5e0e2d22b83ef2e71afac33b2b
 SHA512:
-  metadata.gz: c32e535abdaea1c5361947f781ef81e6db62061840be50f97048a7ea8d4e8ecafe4479a9a43edf04c5eb44847fdddcfdc864332e08f0791bb89be2fdaf7e02d5
-  data.tar.gz: 154e6bb5af6b03eb69d692a94bd5e67e6e10fa28b8caee2247baaa320e01a8744201e0f5ecba6b4a5c1f949972516faec7815defd50d31cf809af7c70243ff43
+  metadata.gz: 5e608a3ad0a435c6daabbbcc07f56e0526f946f31768332e85157fff945911aed2eea695e579a92e19c7036d8b1da0908b6a202a5ec4096c476edde0fc68efa7
+  data.tar.gz: ace91a76675791e03f3d5524aaa9718ef4572d460798eb2a452a96b70210cb308e9b39ec44b91f5047003bec6a71304334b75a9c960a97cdb126057a42bc95c2

data/lib/dynamodb_framework/dynamodb_index.rb

@@ -0,0 +1,119 @@
+module DynamoDbFramework
+  module Index
+
+    class InvalidConfigException < StandardError
+      def initialize(message)
+        super(message)
+      end
+    end
+
+    def config
+      details = {
+          index_name: full_index_name,
+          table: self.instance_variable_get(:@table),
+          partition_key: self.instance_variable_get(:@partition_key)
+      }
+      if self.instance_variable_defined?(:@range_key)
+        details[:range_key] = self.instance_variable_get(:@range_key)
+      end
+      details
+    end
+
+    def index_name(value)
+      self.instance_variable_set(:@index_name, value)
+    end
+
+    def full_index_name
+      unless self.instance_variable_defined?(:@index_name)
+        raise DynamoDbFramework::Index::InvalidConfigException.new('Index name must be specified.')
+      end
+      index_name = self.instance_variable_get(:@index_name)
+      if DynamoDbFramework.namespace != nil
+        index_name = "#{DynamoDbFramework.namespace}#{DynamoDbFramework.namespace_delimiter}#{index_name}"
+      end
+      index_name
+    end
+
+    def table(value)
+      self.instance_variable_set(:@table, value)
+    end
+
+    def partition_key(field, type)
+      self.instance_variable_set(:@partition_key, { field: field, type: type })
+    end
+
+    def range_key(field, type)
+      self.instance_variable_set(:@range_key, { field: field, type: type })
+    end
+
+    def create(store:, read_capacity: 25, write_capacity: 25)
+      unless self.instance_variable_defined?(:@table)
+        raise DynamoDbFramework::Index::InvalidConfigException.new('Table must be specified.')
+      end
+      table = self.instance_variable_get(:@table)
+      table_name = table.config[:table_name]
+
+      unless self.instance_variable_defined?(:@partition_key)
+        raise DynamoDbFramework::Index::InvalidConfigException.new('Partition key must be specified.')
+      end
+      partition_key = self.instance_variable_get(:@partition_key)
+
+      if self.instance_variable_defined?(:@range_key)
+        range_key = self.instance_variable_get(:@range_key)
+      end
+
+      builder = DynamoDbFramework::AttributesBuilder.new
+      builder.add({ name: partition_key[:field], type: partition_key[:type], key: :partition })
+      if range_key != nil
+        builder.add({ name: range_key[:field], type: range_key[:type], key: :range })
+      end
+      if partition_key[:field] != table.config[:partition_key][:field] && range_key != nil && range_key[:field] != table.config[:partition_key][:field]
+        builder.add({ name: table.config[:partition_key][:field], type: table.config[:partition_key][:type] })
+      end
+      if table.config[:range_key] != nil && partition_key[:field] != table.config[:range_key][:field] && range_key != nil && range_key[:field] != table.config[:range_key][:field]
+        builder.add({ name: table.config[:range_key][:field], type: table.config[:range_key][:type] })
+      end
+
+      table_manager = DynamoDbFramework::TableManager.new(store)
+
+      range_key_field = range_key[:field] unless range_key == nil
+
+      index =table_manager.create_global_index(full_index_name, partition_key[:field], range_key_field, read_capacity, write_capacity)
+
+      table_manager.add_index(table_name, builder.attributes, index)
+    end
+
+    def update(store:, read_capacity:, write_capacity:)
+      unless self.instance_variable_defined?(:@table)
+        raise DynamoDbFramework::Index::InvalidConfigException.new('Table must be specified.')
+      end
+      table = self.instance_variable_get(:@table)
+
+      DynamoDbFramework::TableManager.new(store).update_index_throughput(table.config[:table_name], full_index_name, read_capacity, write_capacity)
+    end
+
+    def drop(store:)
+      unless self.instance_variable_defined?(:@table)
+        raise DynamoDbFramework::Index::InvalidConfigException.new('Table must be specified.')
+      end
+      table = self.instance_variable_get(:@table)
+      table_name = table.config[:table_name]
+
+      DynamoDbFramework::TableManager.new(store).drop_index(table_name, full_index_name)
+    end
+
+    def exists?(store:)
+      unless self.instance_variable_defined?(:@table)
+        raise DynamoDbFramework::Index::InvalidConfigException.new('Table must be specified.')
+      end
+      table = self.instance_variable_get(:@table)
+      table_name = table.config[:table_name]
+      DynamoDbFramework::TableManager.new(store).has_index?(table_name, full_index_name)
+    end
+
+    def query(partition:)
+      DynamoDbFramework::Query.new(index_name: config[:index_name], table_name: config[:table].config[:table_name], partition_key: config[:partition_key][:field], partition_value: partition)
+    end
+
+  end
+end

data/lib/dynamodb_framework/dynamodb_query.rb

@@ -0,0 +1,111 @@
+module DynamoDbFramework
+  class Query
+
+    def initialize(table_name:, partition_key:, partition_value:, index_name: nil)
+      @table_name = table_name
+      @partition_key = partition_key
+      @partition_value = partition_value
+      @index_name = index_name
+      @parts = []
+    end
+
+    def method_missing(name)
+      @parts << { type: :field, value: name }
+      self
+    end
+
+    def eq(value)
+      condition(expression: '==', value: value)
+      self
+    end
+
+    def not_eq(value)
+      condition(expression: '!=', value: value)
+      self
+    end
+
+    def gt(value)
+      condition(expression: '>', value: value)
+      self
+    end
+
+    def gt_eq(value)
+      condition(expression: '>=', value: value)
+      self
+    end
+
+    def lt(value)
+      condition(expression: '<', value: value)
+      self
+    end
+
+    def lt_eq(value)
+      condition(expression: '<=', value: value)
+      self
+    end
+
+    def and
+      @parts << { type: :and }
+      self
+    end
+
+    def or
+      @parts << { type: :or }
+      self
+    end
+
+    def execute(store:, limit: nil, count: false)
+      build
+      repository = DynamoDbFramework::Repository.new(store)
+      repository.table_name = @table_name
+      repository.query(@partition_key, @partition_value, nil, nil, @expression_string, @expression_params, @index_name, limit, count)
+    end
+
+    def build
+      @expression_string = ''
+      @expression_params = {}
+
+      counter = 0
+      @parts.each do |p|
+        case p[:type]
+          when :field
+            field_param = '#' + p[:value].to_s
+            @expression_string += ' ' + field_param
+            @expression_params[field_param] = p[:value].to_s
+          when :condition
+            param_name = ':p' + counter.to_s
+            counter = counter + 1
+            @expression_string += ' ' + p[:expression].to_s + ' ' + param_name
+            @expression_params[param_name] = clean_value(p[:value])
+          when :and
+            @expression_string += ' and'
+          when :or
+            @expression_string += ' or'
+          else
+            raise 'Invalid query part'
+        end
+      end
+
+      return @expression_string.strip, @expression_params
+    end
+
+    def condition(expression:, value:)
+      @parts << { type: :condition, expression: expression, value: value }
+    end
+
+    def convert_date(value)
+      klass = value.class
+      return value.iso8601 if klass == DateTime
+      return value.to_i if klass == Time
+    end
+
+    def clean_value(value)
+      if value.is_a?(Time) || value.is_a?(DateTime)
+        convert_date(value)
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/dynamodb_framework/dynamodb_repository.rb

@@ -47,12 +47,34 @@ module DynamoDbFramework
 
     end
 
+    def delete_item(partition_key:, partition_key_value:, range_key: nil, range_key_value: nil)
+
+      keys = {
+          partition_key.to_s => clean_value(partition_key_value)
+      }
+
+      if range_key != nil
+        keys[range_key.to_s] = clean_value(range_key_value)
+      end
+
+      params =
+          {
+              table_name: @table_name,
+              key: keys
+          }
+
+      dynamodb.client.delete_item(params)
+
+      return true
+
+    end
+
     def get_by_key(partition_key, partition_value, range_key = nil, range_value = nil)
 
       key = {}
-      key[partition_key] = partition_value
+      key[partition_key] = clean_value(partition_value)
       if(range_key != nil)
-        key[range_key] = range_value
+        key[range_key] = clean_value(range_value)
       end
 
       params = {
@@ -99,7 +121,7 @@ module DynamoDbFramework
           if key[0] == '#'
             params[:expression_attribute_names][key] = value
           elsif key[0] == ':'
-            params[:expression_attribute_values][key] = value
+            params[:expression_attribute_values][key] = clean_value(value)
           end
         end
 
@@ -147,19 +169,19 @@ module DynamoDbFramework
       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 }
+        params[:expression_attribute_values] = { ':partition_key' => clean_value(partition_key_value), ':range_key' => clean_value(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 }
+        params[:expression_attribute_values] = { ':partition_key' => clean_value(partition_key_value) }
       end
 
       if expression_params != nil
         expression_params.each do |key, value|
           if key[0] == '#'
-            params[:expression_attribute_names][key] = value
+            params[:expression_attribute_names][key] = clean_value(value)
           elsif key[0] == ':'
-            params[:expression_attribute_values][key] = value
+            params[:expression_attribute_values][key] = clean_value(value)
           end
         end
 
@@ -222,5 +244,13 @@ module DynamoDbFramework
       return value.iso8601 if klass == DateTime
       return value.to_i if klass == Time
     end
+
+    def clean_value(value)
+      if value.is_a?(Time) || value.is_a?(DateTime)
+        convert_date(value)
+      else
+        value
+      end
+    end
   end
 end

data/lib/dynamodb_framework/dynamodb_table.rb

@@ -0,0 +1,114 @@
+module DynamoDbFramework
+  module Table
+
+    class InvalidConfigException < StandardError
+      def initialize(message)
+        super(message)
+      end
+    end
+
+    def config
+      details = {
+          table_name: full_table_name,
+          partition_key: self.instance_variable_get(:@partition_key)
+      }
+      if self.instance_variable_defined?(:@range_key)
+        details[:range_key] = self.instance_variable_get(:@range_key)
+      end
+      details
+    end
+
+    def table_name(value)
+      self.instance_variable_set(:@table_name, value)
+    end
+
+    def full_table_name
+      unless self.instance_variable_defined?(:@table_name)
+        raise DynamoDbFramework::Table::InvalidConfigException.new('Table name must be specified.')
+      end
+      table_name = self.instance_variable_get(:@table_name)
+      if DynamoDbFramework.namespace != nil
+        table_name = "#{DynamoDbFramework.namespace}#{DynamoDbFramework.namespace_delimiter}#{table_name}"
+      end
+      table_name
+    end
+
+    def partition_key(field, type)
+      self.instance_variable_set(:@partition_key, { field: field, type: type })
+    end
+
+    def range_key(field, type)
+      self.instance_variable_set(:@range_key, { field: field, type: type })
+    end
+
+    def create(store:, read_capacity: 25, write_capacity: 25)
+      unless self.instance_variable_defined?(:@partition_key)
+        raise DynamoDbFramework::Table::InvalidConfigException.new('Partition key must be specified.')
+      end
+      partition_key = self.instance_variable_get(:@partition_key)
+
+      if self.instance_variable_defined?(:@range_key)
+        range_key = self.instance_variable_get(:@range_key)
+      end
+
+      builder = DynamoDbFramework::AttributesBuilder.new
+      builder.add({ name: partition_key[:field], type: partition_key[:type], key: :partition })
+      if range_key != nil
+        builder.add({ name: range_key[:field], type: range_key[:type], key: :range })
+      end
+
+      DynamoDbFramework::TableManager.new(store).create_table({ name: full_table_name, attributes: builder.attributes, read_capacity: read_capacity, write_capacity: write_capacity })
+    end
+
+    def update(store:, read_capacity:, write_capacity:)
+      DynamoDbFramework::TableManager.new(store).update_throughput(full_table_name, read_capacity, write_capacity)
+    end
+
+    def drop(store:)
+      DynamoDbFramework::TableManager.new(store).drop(full_table_name)
+    end
+
+    def exists?(store:)
+      DynamoDbFramework::TableManager.new(store).exists?(full_table_name)
+    end
+
+    def query(partition:)
+      DynamoDbFramework::Query.new(table_name: config[:table_name], partition_key: config[:partition_key][:field], partition_value: partition)
+    end
+
+    def all(store:)
+      repository = DynamoDbFramework::Repository.new(store)
+      repository.table_name = config[:table_name]
+      repository.all
+    end
+
+    def put_item(store:, item:)
+      repository = DynamoDbFramework::Repository.new(store)
+      repository.table_name = config[:table_name]
+      repository.put(item)
+    end
+
+    def get_item(store:, partition:, range: nil)
+      repository = DynamoDbFramework::Repository.new(store)
+      repository.table_name = config[:table_name]
+
+      if range != nil
+        repository.get_by_key(config[:partition_key][:field], partition, config[:range_key][:field], range)
+      else
+        repository.get_by_key(config[:partition_key][:field], partition)
+      end
+    end
+
+    def delete_item(store:, partition:, range: nil)
+      repository = DynamoDbFramework::Repository.new(store)
+      repository.table_name = config[:table_name]
+
+      if range != nil
+        range_key = config[:range_key][:field]
+      end
+
+      repository.delete_item(partition_key: config[:partition_key][:field], partition_key_value: partition, range_key: range_key, range_key_value: range)
+    end
+
+  end
+end

data/lib/dynamodb_framework/version.rb

@@ -1,3 +1,3 @@
 module DynamoDbFramework
-  VERSION = '1.3.0'
+  VERSION = '1.4.0'
 end

data/lib/dynamodb_framework.rb

@@ -1,3 +1,5 @@
+require 'hash_kit'
+require 'json'
 require_relative 'dynamodb_framework/version'
 require_relative 'dynamodb_framework/dynamodb_attributes_builder'
 require_relative 'dynamodb_framework/dynamodb_store'
@@ -8,5 +10,23 @@ require_relative 'dynamodb_framework/dynamodb_migration_script'
 require_relative 'dynamodb_framework/dynamodb_logger'
 require_relative 'dynamodb_framework/hash_helper'
 require_relative 'dynamodb_framework/dynamodb_namespace_migration_manager'
+require_relative 'dynamodb_framework/dynamodb_table'
+require_relative 'dynamodb_framework/dynamodb_index'
+require_relative 'dynamodb_framework/dynamodb_query'
 
 require 'date'
+
+module DynamoDbFramework
+  def self.namespace=(value)
+    @namespace = value
+  end
+  def self.namespace
+    @namespace
+  end
+  def self.namespace_delimiter=(value)
+    @namespace_delimiter = value
+  end
+  def self.namespace_delimiter
+    @namespace_delimiter ||= '.'
+  end
+end

data/spec/dynamodb_index_spec.rb

@@ -0,0 +1,212 @@
+RSpec.describe DynamoDbFramework::Index do
+
+  let(:store) do
+    DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+  end
+
+  let(:table_manager) do
+    DynamoDbFramework::TableManager.new(store)
+  end
+
+  let(:table_name) { ExampleTable.config[:table_name] }
+
+  before do
+    ExampleTable.create(store: store)
+  end
+
+  describe '#create' do
+    context 'when a valid index class calls the create method' do
+      context 'with a range key' do
+        let(:index_name) { ExampleIndex.config[:index_name] }
+        before do
+          if table_manager.has_index?(table_name, index_name)
+            table_manager.drop_index(table_name, index_name)
+          end
+        end
+        it 'should create the index' do
+          expect(table_manager.has_index?(table_name, index_name)).to be false
+          ExampleIndex.create(store: store)
+          expect(table_manager.has_index?(table_name, index_name)).to be true
+        end
+      end
+
+      context 'without a range key' do
+        let(:index_name) { ExampleIndexWithoutRangeKey.config[:index_name] }
+        before do
+          if table_manager.has_index?(table_name, index_name)
+            table_manager.drop_index(table_name, index_name)
+          end
+        end
+        it 'should create the table' do
+          expect(table_manager.has_index?(table_name, index_name)).to be false
+          ExampleIndexWithoutRangeKey.create(store: store)
+          expect(table_manager.has_index?(table_name, index_name)).to be true
+        end
+      end
+    end
+    context 'when an invalid index class calls the create method' do
+      context 'without a index_name specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutIndexName.create(store: store) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+      context 'without a table specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutTable.create(store: store) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+      context 'without a partition_key specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutPartitionKey.create(store: store) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    context 'when a valid index class calls the update method' do
+      let(:index_name) { ExampleIndex.config[:index_name] }
+      before do
+        if table_manager.has_index?(table_name, index_name)
+          table_manager.drop_index(table_name, index_name)
+        end
+        ExampleIndex.create(store: store)
+      end
+      it 'should update the index' do
+        ExampleIndex.update(store: store, read_capacity: 50, write_capacity: 50)
+      end
+    end
+    context 'when an invalid index class calls the update method' do
+      context 'without an index_name specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutIndexName.update(store: store, read_capacity: 50, write_capacity: 50) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+      context 'without a table specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutTable.update(store: store, read_capacity: 50, write_capacity: 50) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+    end
+  end
+
+  describe '#drop' do
+    context 'when a valid index class calls the drop method' do
+      let(:index_name) { ExampleIndex.config[:index_name] }
+      before do
+        if table_manager.has_index?(table_name, index_name)
+          table_manager.drop_index(table_name, index_name)
+        end
+        ExampleIndex.create(store: store)
+      end
+      it 'should drop the index' do
+        ExampleIndex.drop(store: store)
+        expect(table_manager.has_index?(table_name, index_name)).to be false
+      end
+    end
+    context 'when an invalid index class calls the drop method' do
+      context 'without an index_name specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutIndexName.drop(store: store) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+      context 'without a table specified' do
+        it 'should raise an exception' do
+          expect{ ExampleIndexWithoutTable.drop(store: store) }.to raise_error(DynamoDbFramework::Index::InvalidConfigException)
+        end
+      end
+    end
+  end
+
+  describe '#exists?' do
+    context 'when the index exists' do
+      let(:index_name) { ExampleIndex.config[:index_name] }
+      before do
+        if table_manager.has_index?(table_name, index_name)
+          table_manager.drop_index(table_name, index_name)
+        end
+        ExampleIndex.create(store: store)
+      end
+      it 'should return true' do
+        expect(ExampleIndex.exists?(store: store)).to be true
+      end
+    end
+    context 'when the index does NOT exist' do
+      let(:index_name) { ExampleIndex.config[:index_name] }
+      before do
+        if table_manager.has_index?(table_name, index_name)
+          table_manager.drop_index(table_name, index_name)
+        end
+      end
+      it 'should return false' do
+        expect(ExampleIndex.exists?(store: store)).to be false
+      end
+    end
+  end
+
+  describe '#query' do
+
+    let(:repository) do
+      DynamoDbFramework::Repository.new(store)
+    end
+
+    let(:table_name) { ExampleTable.config[:table_name] }
+    let(:index_name) { ExampleIndex.config[:index_name] }
+
+    def create_query_item(name, number)
+      item = TestItem.new
+      item.id = SecureRandom.uuid
+      item.name = name
+      item.timestamp = Time.now
+      item.number = number
+      repository.table_name = table_name
+      repository.put(item)
+    end
+
+    before do
+      table_manager.drop(table_name)
+      ExampleTable.create(store: store)
+      ExampleIndex.create(store: store)
+
+      create_query_item('name 1', 1)
+      create_query_item('name 1', 2)
+      create_query_item('name 1', 3)
+      create_query_item('name 1', 4)
+      create_query_item('name 2', 1)
+      create_query_item('name 2', 2)
+      create_query_item('name 2', 3)
+      create_query_item('name 3', 1)
+      create_query_item('name 3', 2)
+    end
+
+    it 'should return the expected items' do
+      results = ExampleIndex.query(partition: 'name 1')
+                    .number.gt_eq(1)
+                    .and
+                    .number.lt_eq(5)
+                    .execute(store: store)
+      expect(results.length).to eq 4
+    end
+    context 'when limit is specified' do
+      it 'should return the expected items' do
+        results = ExampleIndex.query(partition: 'name 1')
+                      .number.gt_eq(1)
+                      .and
+                      .number.lt_eq(5)
+                      .execute(store: store, limit: 1)
+        expect(results.length).to eq 1
+      end
+    end
+    context 'when count is specified' do
+      it 'should return the expected count' do
+        count = ExampleIndex.query(partition: 'name 1')
+                    .number.gt_eq(1)
+                    .and
+                    .number.lt_eq(5)
+                    .execute(store: store, count: 4)
+        expect(count).to eq 4
+      end
+    end
+  end
+
+end