dymos 0.1.4 → 0.2.0

data/lib/dymos/query/get_item.rb

@@ -1,18 +1,39 @@
 module Dymos
   module Query
-    class GetItem < ::Dymos::Query::Builder
+    class GetItem < Base
 
-      def key(params)
-        @key = params
+      def command
+        'get_item'
+      end
+
+      def key(value)
+        @query[:key] = value.deep_stringify_keys
+        self
+      end
+
+      def attributes(*value)
+        @query[:attributes_to_get] = value
+        self
+      end
+
+      def consistent_read(value)
+        @query[:consistent_read] = value
         self
       end
 
-      def query
-        {
-            table_name: @table_name.to_s,
-            key: @key,
-            consistent_read: true,
-        }
+      def return_consumed_capacity(value)
+        @query[:return_consumed_capacity] = value.to_s.upcase
+        self
+      end
+
+      def projection_expression(value)
+        @query[:projection_expression] = value
+        self
+      end
+
+      def expression_attribute_names(value)
+        @query[:expression_attribute_names] = value.deep_stringify_keys
+        self
       end
     end
   end

data/lib/dymos/query/put_item.rb

@@ -1,48 +1,74 @@
 module Dymos
   module Query
-    class PutItem < ::Dymos::Query::Builder
-
-      def item(params)
-        @item = params
-        self
-      end
-
-      def expected(params)
-        @expected = Hash[params.map do |name, expression|
-          operator, values = expression.split(' ', 2)
-          if values.nil?
-            value1 = operator
-            [name, ::Dymos::Query::Expect.new.condition(operator, nil).data]
-          else
-            value1, value2 = values.split(' ')
-            if value2.present?
-              [name, ::Dymos::Query::Expect.new.condition(operator, values).data]
-            else
-              [name, ::Dymos::Query::Expect.new.condition(operator, value1).data]
-            end
-          end
-
-        end]
-        self
-      end
-
-      def query
-        data = {
-            table_name: @table_name.to_s,
-            item: @item,
-            return_values: @return_values || 'ALL_OLD',
-            # return_consumed_capacity: @return_consumed_capacity || 'TOTAL',
-            # return_item_collection_metrics: @return_item_collection_metrics || 'SIZE',
-        }
-
-        if @expected.present?
-          data[:expected] = @expected
-          if @expected.size > 1
-            data[:conditional_operator] = @conditional_operator || 'AND'
-          end
+    class PutItem < Base
+      def command
+        'put_item'
+      end
+
+      def item(value)
+        @query[:item] = value.deep_stringify_keys
+        self
+      end
+
+      def expected(value)
+        value.map { |v| add_expected(*v) }
+        self
+      end
+
+      def add_expected(*value)
+        if value.count == 2
+          column, operator, value = value[0], :eq, value[1]
+        else
+          column, operator, value = value
         end
-        data
+        @query[:expected] ||= {}
+        @query[:expected].store(*_add_expected(column, operator, value))
+        self
+      end
+
+      def _add_expected(column, operator, value)
+        [column.to_s, {
+                      attribute_value_list: ([:BETWEEN, :IN].include? operator) ? [*value] : [value],
+                      comparison_operator: operator.to_s.upcase
+                    }
+        ]
+      end
+
+      def return_values(value)
+        @query[:return_values] = value.to_s.upcase
+        self
+      end
+
+      def return_consumed_capacity(value)
+        @query[:return_consumed_capacity] = value.to_s.upcase
+        self
       end
+
+      def return_item_collection_metrics(value)
+        @query[:return_item_collection_metrics] = value.to_s.upcase
+        self
+      end
+
+      def conditional_operator(value)
+        @query[:conditional_operator] = value.to_s.upcase
+        self
+      end
+
+      def condition_expression(value)
+        @query[:condition_expression] = value
+        self
+      end
+
+      def expression_attribute_names(value)
+        @query[:expression_attribute_names] = value.deep_stringify_keys
+        self
+      end
+
+      def expression_attribute_values(value)
+        @query[:expression_attribute_values] = value.deep_stringify_keys
+        self
+      end
+
     end
   end
 end

data/lib/dymos/query/query.rb

@@ -1,40 +1,126 @@
 module Dymos
   module Query
-    class Query < ::Dymos::Query::Builder
+    class Query < Base
 
-      def key_conditions(params)
-        @key = Hash[params.map do |name, expression|
-          operator, values = expression.split(' ', 2)
-          if values.nil?
-            [name, ::Dymos::Query::Expect.new.condition(operator, nil).data(true)]
-          else
-            value1, value2 = values.split(' ')
-            if value2.present?
-              [name, ::Dymos::Query::Expect.new.condition(operator, values).data(true)]
-            else
-              [name, ::Dymos::Query::Expect.new.condition(operator, value1).data(true)]
-            end
-          end
+      def command
+        'query'
+      end
+
+      def index(value)
+        @query[:index_name] = value.to_s
+        self
+      end
+
+      def attributes(*value)
+        @query[:attributes_to_get] = value
+        self
+      end
+
+      def limit(value)
+        @query[:limit] = value
+        self
+      end
+
+      def consistent_read(value)
+        @query[:consistent_read] = value
+        self
+      end
 
-        end]
+      def where(*value)
+        if value.count == 1 && value[0].is_a?(Hash)
+          value[0].each { |k, v| add_conditions(k, :eq, v) }
+        else
+          value.each { |v| add_conditions(*v) }
+        end
         self
       end
 
-      def index_name(name)
-        @index_name =name
+      def conditions(value)
+        value.map { |v| add_conditions(*v) }
         self
       end
 
-      def query
-        data = {
-            table_name: @table_name.to_s,
-            key_conditions: @key,
-            consistent_read: false
-        }
-        if @index_name.present?
-          data[:index_name] = @index_name.to_s
+      def add_conditions(*value)
+        if value.count == 2
+          column, operator, value = value[0], :eq, value[1]
+        else
+          column, operator, value = value
         end
-        data
+        @query[:key_conditions] ||= {}
+        @query[:key_conditions].store(*_add_filter(column, operator, value))
+        self
+      end
+
+
+      def comparison_operator(value)
+        @query[:comparison_operator] = value.to_s.upcase
+        self
+      end
+
+      def filter(value, operator='AND')
+        value.map { |v| add_filter(*v) }
+        filter_operator operator.to_s.upcase if value.count > 1
+        self
+      end
+
+      def add_filter(*value)
+        if value.count == 2
+          column, operator, value = value[0], :eq, value[1]
+        else
+          column, operator, value = value
+        end
+        @query[:query_filter] ||= {}
+        @query[:query_filter].store(*_add_filter(column, operator, value))
+        filter_operator 'AND' if @query[:conditional_operator].blank? && @query[:query_filter].count > 1
+        self
+      end
+
+      def _add_filter(column, operator, value)
+        [column.to_s, {
+                      attribute_value_list: [*value],
+                      comparison_operator: operator.to_s.upcase
+                    }
+        ]
+      end
+
+      def filter_operator(value)
+        @query[:conditional_operator] = value.to_s.upcase
+        self
+      end
+
+      def asc
+        scan_index_forward true
+      end
+
+      def desc
+        scan_index_forward false
+      end
+
+      def scan_index_forward(value)
+        @query[:scan_index_forward] = value
+        self
+      end
+
+      def exclusive_start_key(value)
+        @query[:exclusive_start_key] = value.deep_stringify_keys
+        self
+      end
+
+      alias :start_key :exclusive_start_key
+
+      def return_consumed_capacity(value)
+        @query[:return_consumed_capacity] = value.to_s.upcase
+        self
+      end
+
+      def projection_expression(value)
+        @query[:projection_expression] = value
+        self
+      end
+
+      def expression_attribute_names(value)
+        @query[:expression_attribute_names] = value.deep_stringify_keys
+        self
       end
     end
   end

data/lib/dymos/query/scan.rb

@@ -1,25 +1,98 @@
 module Dymos
   module Query
-    class Scan < ::Dymos::Query::Builder
+    class Scan < Base
+      def command
+        'scan'
+      end
+
+      def attributes(*value)
+        @query[:attributes_to_get] = value
+        self
+      end
+
+      def limit(value)
+        @query[:limit] = value
+        self
+      end
+
+      def select(value)
+        @query[:select] = value
+        self
+      end
 
-      def limit(params)
-        @limit = params
+      def filter(value, operator='AND')
+        value.map { |v| add_filter(*v) }
+        filter_operator operator.to_s.upcase if value.count > 1
         self
       end
 
-      def exclusive_start_key(params)
-        @exclusive_start_key = params
+      def add_filter(*value)
+        if value.count == 2
+          column, operator, value = value[0], :eq, value[1]
+        else
+          column, operator, value = value
+        end
+        @query[:scan_filter] ||= {}
+        @query[:scan_filter].store(*_add_filter(column, operator, value))
+        filter_operator 'AND' if @query[:conditional_operator].blank? && @query[:scan_filter].count > 1
         self
       end
 
-      def query
-        data = {
-            table_name: @table_name.to_s,
-        }
-        data[:limit] = @limit if @limit.present?
-        data[:exclusive_start_key] = @exclusive_start_key if @exclusive_start_key.present?
-        data
+      def _add_filter(column, operator, value)
+        [column.to_s, {
+                      attribute_value_list: [*value],
+                      comparison_operator: operator.to_s.upcase
+                    }
+        ]
+      end
+
+      def filter_operator(value)
+        @query[:conditional_operator] = value.to_s.upcase
+        self
+      end
+
+      def exclusive_start_key(value)
+        @query[:exclusive_start_key] = value.deep_stringify_keys
+        self
+      end
+
+      alias :start_key :exclusive_start_key
+
+      def return_consumed_capacity(value)
+        @query[:return_consumed_capacity] = value.to_s.upcase
+        self
       end
+
+      def total_segments(value)
+        @query[:total_segments] = value
+        self
+      end
+
+      def segment(value)
+        @query[:segment] = value
+        self
+      end
+
+      def projection_expression(value)
+        @query[:projection_expression] = value
+        self
+      end
+
+      def filter_expression(value)
+        @query[:filter_expression] = value
+        self
+      end
+
+      def expression_attribute_names(value)
+        @query[:expression_attribute_names] = value.deep_stringify_keys
+        self
+      end
+
+      def expression_attribute_values(value)
+        @query[:expression_attribute_values] = value.deep_stringify_keys
+        self
+      end
+
     end
   end
 end

data/lib/dymos/query/update_item.rb

@@ -1,72 +1,119 @@
 module Dymos
   module Query
-    class UpdateItem < ::Dymos::Query::Builder
+    class UpdateItem < Base
+      def command
+        'update_item'
+      end
 
-      # @param [String] name
-      # @return [self]
-      def key(name)
-        @key = name
+      def key(value)
+        @query[:key] = value.deep_stringify_keys
         self
       end
 
-      # @param [Hash] param
-      # @param [String] action
-      # @return [self]
-      def attribute_updates(param, action="put")
-        @attribute_updates||={}
-        param.each { |key, value|
-          @attribute_updates[key] = {
-              value: value,
-              action: action.upcase
-          }
-        }
+      def add(column, value)
+        add_attribute_updates(column, :add, value)
         self
       end
 
-      # @param [Hash] params
-      # @return [self]
-      def expected(params)
-        @expected = Hash[params.map do |name, expression|
-          operator, values = expression.split(' ', 2)
-          if values.nil?
-            [name, ::Dymos::Query::Expect.new.condition(operator, nil).data]
-          else
-            value1, value2 = values.split(' ')
-            if value2.present?
-              [name, ::Dymos::Query::Expect.new.condition(operator, values).data]
-            else
-              [name, ::Dymos::Query::Expect.new.condition(operator, value1).data]
-            end
-          end
+      def put(column, value)
+        add_attribute_updates(column, :put, value)
+        self
+      end
 
-        end]
+      def delete(column, value)
+        add_attribute_updates(column, :delete, value)
         self
       end
 
-      # @param [String] value
-      # @return [self]
-      def return_values(value)
-        @return_values = value.upcase
+      def attribute_updates(*value)
+        value.map { |v| add_attribute_updates(*v) }
         self
       end
 
-      # @return [Hash]
-      def query
-        data = {
-            table_name: @table_name.to_s,
-            key: @key,
-            attribute_updates: @attribute_updates,
-            return_values: @return_values || 'ALL_NEW',
-        }
+      def add_attribute_updates(*value)
+        if value.count == 2
+          column, operator, value = value[0], :put, value[1]
+        else
+          column, operator, value = value
+        end
+        @query[:attribute_updates] ||= {}
+        @query[:attribute_updates].store(*_attribute_updates(column, operator, value))
+        self
+      end
+
+      def _attribute_updates(column, action, value)
+        [column.to_s, {
+                      value: value,
+                      action: action.to_s.upcase
+                    }
+        ]
+      end
 
-        if @expected.present?
-          data[:expected] = @expected
-          if @expected.size > 1
-            data[:conditional_operator] = @conditional_operator || 'AND'
-          end
+      def expected(value)
+        value.map { |v| add_expected(*v) }
+        self
+      end
+
+      def add_expected(*value)
+        if value.count == 2
+          column, operator, value = value[0], :eq, value[1]
+        else
+          column, operator, value = value
         end
-        data
+        @query[:expected] ||= {}
+        @query[:expected].store(*_add_expected(column, operator, value))
+        self
+      end
+
+      def _add_expected(column, operator, value)
+        [column.to_s, {
+                      attribute_value_list: ([:BETWEEN, :IN].include? operator) ? [*value] : [value],
+                      comparison_operator: operator.to_s.upcase
+                    }
+        ]
+      end
+
+      def conditional_operator(value)
+        @query[:conditional_operator] = value.to_s.upcase
+        self
+      end
+
+
+      def return_values(value)
+        @query[:return_values] = value.to_s.upcase
+        self
+      end
+
+      def return_consumed_capacity(value)
+        @query[:return_consumed_capacity] = value.to_s.upcase
+        self
+      end
+
+      def return_item_collection_metrics(value)
+        @query[:return_item_collection_metrics] = value.to_s.upcase
+        self
+      end
+
+      def update_expression(value)
+        @query[:update_expression] = value
+        self
       end
+
+      def condition_expression(value)
+        @query[:condition_expression] = value
+        self
+      end
+
+      def expression_attribute_names(value)
+        @query[:expression_attribute_names] = value.deep_stringify_keys
+        self
+      end
+
+      def expression_attribute_values(value)
+        @query[:expression_attribute_values] = value.deep_stringify_keys
+        self
+      end
+
     end
   end
 end

data/lib/dymos/version.rb

@@ -1,3 +1,3 @@
 module Dymos
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/dymos.rb

@@ -1,6 +1,7 @@
-require "dymos/query/attribute"
-require "dymos/query/expect"
-require "dymos/query/builder"
+require 'active_support/all'
+
+require "dymos/config"
+require "dymos/query/base"
 require "dymos/query/put_item"
 require "dymos/query/update_item"
 require "dymos/query/delete_item"
@@ -8,10 +9,11 @@ require "dymos/query/get_item"
 require "dymos/query/describe"
 require "dymos/query/scan"
 require "dymos/query/query"
+require "dymos/query/create_table"
 require "dymos/attribute"
-require "dymos/command"
 require "dymos/persistence"
 require "dymos/model"
+require "dymos/client"
 require "dymos/version"
 
 module Dymos

data/spec/lib/dymos/client_spec.rb

@@ -0,0 +1,4 @@
+describe Dymos::Client do
+
+end
+

data/spec/lib/dymos/config_spec.rb

@@ -0,0 +1,11 @@
+describe Dymos::Config do
+  it 'config set' do
+    Dymos::Config.default[:update_item]={
+      return_values: 'ALL_OLD'
+    }
+
+    expect(Dymos::Config.default[:update_item]).to eq(return_values: 'ALL_OLD')
+
+    Dymos::Config.default[:update_item]={}
+  end
+end