commutator 0.1.0

data/lib/commutator/options/query.rb

@@ -0,0 +1,73 @@
+module Commutator
+  module Options
+    class Query
+      include Util::Fluent
+
+      fluent_accessor :key_condition_expression,
+                      :filter_expression,
+                      :projection_expression,
+                      :consistent_read,
+                      :expression_attribute_values,
+                      :expression_attribute_names,
+                      :exclusive_start_key,
+                      :index_name,
+                      :return_consumed_capacity,
+                      :scan_index_forward,
+                      :select,
+                      :table_name,
+                      :limit
+
+      fluent_wrapper :key_condition_expression,
+                     :filter_expression,
+                     :projection_expression,
+                     :expression_attribute_values,
+                     :expression_attribute_names,
+                     :exclusive_start_key
+
+      def initialize
+        @expression_attribute_values ||= Expressions::AttributeValues.new
+        @expression_attribute_names ||= Expressions::AttributeNames.new
+
+        @key_condition_expression ||= Expressions::ConditionExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+
+        @filter_expression ||= Expressions::ConditionExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+
+        @projection_expression ||= Expressions::ProjectionExpression.new(
+          attribute_names: @expression_attribute_names)
+      end
+
+      def asc
+        scan_index_forward(true)
+      end
+
+      def desc
+        scan_index_forward(false)
+      end
+
+      def to_h
+        hash = {
+          table_name: table_name,
+          limit: limit,
+          consistent_read: consistent_read,
+          index_name: index_name,
+          select: select,
+          exclusive_start_key: exclusive_start_key,
+          scan_index_forward: scan_index_forward,
+          return_consumed_capacity: return_consumed_capacity,
+          projection_expression: projection_expression.to_s,
+          expression_attribute_names: expression_attribute_names.to_h,
+          expression_attribute_values: expression_attribute_values.to_h,
+          key_condition_expression: key_condition_expression.to_s(wrap: false),
+          filter_expression: filter_expression.to_s(wrap: false)
+        }
+
+        hash.keep_if { |_key, value| value.present? || value == false }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/commutator/options/scan.rb

@@ -0,0 +1,60 @@
+module Commutator
+  module Options
+    class Scan
+      include Util::Fluent
+
+      fluent_accessor :expression_attribute_values,
+                      :expression_attribute_names,
+                      :filter_expression,
+                      :projection_expression,
+                      :consistent_read,
+                      :exclusive_start_key,
+                      :index_name,
+                      :limit,
+                      :select,
+                      :return_consumed_capacity,
+                      :segment,
+                      :table_name,
+                      :total_segments
+
+      fluent_wrapper :expression_attribute_values,
+                     :expression_attribute_names,
+                     :filter_expression,
+                     :projection_expression,
+                     :exclusive_start_key
+
+      def initialize
+        @expression_attribute_values = Expressions::AttributeValues.new
+        @expression_attribute_names = Expressions::AttributeNames.new
+
+        @filter_expression = Expressions::ConditionExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+
+        @projection_expression = Expressions::ProjectionExpression.new(
+          attribute_names: @expression_attribute_names)
+      end
+
+      def to_h
+        hash = {
+          projection_expression: projection_expression.to_s,
+          expression_attribute_values: expression_attribute_values.to_h,
+          expression_attribute_names: expression_attribute_names.to_h,
+          filter_expression: filter_expression.to_s(wrap: false),
+          consistent_read: consistent_read,
+          exclusive_start_key: exclusive_start_key,
+          index_name: index_name,
+          limit: limit,
+          select: select,
+          return_consumed_capacity: return_consumed_capacity,
+          table_name: table_name,
+          total_segments: total_segments,
+          segment: segment
+        }
+
+        hash.keep_if { |_key, value| value.present? || value == false }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/commutator/options/update_item.rb

@@ -0,0 +1,55 @@
+module Commutator
+  module Options
+    class UpdateItem
+      include Util::Fluent
+
+      fluent_accessor :key,
+                      :expression_attribute_names,
+                      :expression_attribute_values,
+                      :update_expression,
+                      :condition_expression,
+                      :return_values,
+                      :return_consumed_capacity,
+                      :return_item_collection_metrics,
+                      :table_name
+
+      fluent_wrapper :key,
+                     :expression_attribute_names,
+                     :expression_attribute_values,
+                     :update_expression,
+                     :condition_expression
+
+      def initialize
+        @key = {}
+
+        @expression_attribute_names = Expressions::AttributeNames.new
+        @expression_attribute_values = Expressions::AttributeValues.new
+
+        @update_expression = Expressions::UpdateExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+
+        @condition_expression = Expressions::ConditionExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+      end
+
+      def to_h
+        hash = {
+          key: key,
+          expression_attribute_names: expression_attribute_names.to_h,
+          expression_attribute_values: expression_attribute_values.to_h,
+          condition_expression: condition_expression.to_s(wrap: false),
+          update_expression: update_expression.to_s,
+          return_values: return_values,
+          return_consumed_capacity: return_consumed_capacity,
+          return_item_collection_metrics: return_item_collection_metrics,
+          table_name: table_name
+        }
+
+        hash.keep_if { |_key, value| value.present? || value == false }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/commutator/simple_client.rb

@@ -0,0 +1,27 @@
+module Commutator
+  # Provides an instance of `Aws::DynamoDB::Client` with conversions for passing
+  # Commutator objects to API operations.
+  #
+  # `:client => ` may be provided as an `Aws::DynamoDB::Client` instance
+  # otherwise this instantiates a `Aws::DynamoDB::Client` with the provided options
+  class SimpleClient < SimpleDelegator
+    def initialize(client: nil, **options)
+      return super(client) if client
+
+      defaults = {
+        region: "us-east-1",
+        endpoint: "https://dynamodb.us-east-1.amazonaws.com",
+      }
+      options = defaults.merge options
+
+      super Aws::DynamoDB::Client.new(options)
+    end
+
+    # `**kwargs` automatically calls `to_hash` on Options instances
+    API_OPERATIONS.each do |operation|
+      define_method(operation) do |**kwargs|
+        super kwargs
+      end
+    end
+  end
+end

data/lib/commutator/util/fluent.rb

@@ -0,0 +1,67 @@
+module Commutator
+  module Util
+    # This module provides fluent accessors and wrappers, which are probably
+    # just terms I made up.
+    #
+    # Usage:
+    # class Person
+    #   include Commutator::Util::Fluent
+    #
+    #   fluent_accessor :first_name,
+    #                   :last_name,
+    #                   :pets
+    #
+    #   fluent_wrapper :pets
+    #
+    #   def initialize
+    #     @pets = []
+    #   end
+    # end
+    #
+    # When called with an argument a fluent accessor will set a value
+    # and return the instance again. This allows chaining.
+    #
+    # Ex:
+    # person = Person.new.first_name('Seymour').last_name('Busses')
+    # # => <#Person @first_name='Seymour', @last_name='Busses'>
+    #
+    # When called without an argument a fluent accessor will return the value
+    # it has.
+    # person = Person.new.first_name('Seymour')
+    # person.first_name # => 'Seymour'
+    #
+    # A fluent wrapper allows you to manipulate "complex" objects and continue
+    # to chain calls. Fluent wrappers start with a `with_` followed by the
+    # attribute name. Fluent wrapper passes the value into a block.
+    #
+    # Ex:
+    # person = Person.new
+    #          .first_name('Hi')
+    #          .with_pets { |pets| pets << 'mittens' }
+    #
+    module Fluent
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def fluent_wrapper(*attr_names)
+          attr_names.each do |attr_name|
+            define_method "with_#{attr_name}" do |&block|
+              block.call(instance_variable_get("@#{attr_name}"))
+              self
+            end
+          end
+        end
+
+        def fluent_accessor(*attr_names)
+          attr_names.each do |attr_name|
+            define_method attr_name do |*val|
+              return instance_variable_get("@#{attr_name}") if val.empty?
+              instance_variable_set("@#{attr_name}", val.first)
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end