dymos 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f5e6582dcf6a0992c22f3d13d6fcb87fec0bd0f
-  data.tar.gz: bc4a0800891429d8a80eeeeb08c2250f594c3709
+  metadata.gz: a14520d556c3eb1c8f019feca759dc4a8c0bf530
+  data.tar.gz: b3d32561a640e4c08611a6df6aa62afe6e7e3f8f
 SHA512:
-  metadata.gz: 1053e6b53a07c7cd72357860c883e46b5d38151fb3fe0f0cca29391a36501814b21359442c21d20c64b0b1c875b37a3983020cc3cd705758104e2513883e32ce
-  data.tar.gz: 1204f174b48bc4a007bfa973738f5e4c06d03e7eab8e6a03e3c38dfefbd05935669ae833ee49c4407ab307e477d3a355aa947c47f8ca924c003d8d20fc04d8e7
+  metadata.gz: 3715cc421b3f4453ecfd1e88b1bcb544faf74bf522498bcf77a8f53b2b1119b3563cad5d508a228497ffa2c13d1a0b78f2006783fa6b18de8fd1238fc8403bf6
+  data.tar.gz: 1a5ffcbe966d215d3c40605068414ded37b5a692d094ad99d71c9d01c12432f602df60029e59c09c9b13787c53ca4352742db6ebb6358b438893ab56ce3a1664

data/README.md

@@ -18,11 +18,80 @@ install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+
+### テーブル生成
+
+```ruby
+Dymos::Query::CreateTable.name('ProductCatalogs')
+  .attributes(category: 'S', title: 'S', ISBN:'S', price:'N')
+  .keys(category: 'HASH', title: 'RANGE')
+  .gsi([{name: 'global_index_isbn', keys: {ISBN: 'HASH'}, projection: {type: 'INCLUDE', attributes: [:title, :ISBN]}, throughput: {read: 20, write: 10}}])
+  .lsi([{name: 'local_index_category_price', keys: {category: 'HASH', price: 'RANGE'}}])
+  .throughput(read: 20, write: 10)
+```
+
+### モデル定義
+
+```ruby
+class Product < Dymos::Model
+    table 'ProductCatalogs'
+    field :category, :integer
+    field :title, :string
+    field :ISBN, :string
+    field :price, :integer
+    field :authors, :array
+    field :created_at, :time
+  end
+```
+
+### クエリ
+#### 取得
+
+```ruby
+Product.all
+```
+
+```ruby
+Product.find('Novels', 'The Catcher in the Rye') #key is category && title
+```
+
+```ruby
+Product.where(category:'Comics').all
+Product.where(category:'Comics').add_filter(:authors,:contains,'John Smith').all
+Product.where(category:'Comics').desc.one
+Product.index(:local_index_category_price).add_condition(:category,'Comics')add_condition(:price,:gt,10000).all
+```
+
+#### 保存
+
+##### 新規
+```ruby
+product = Product.new(params)
+product.save!
+```
+
+##### 更新
+```ruby
+product = Product.find(conditions)
+product.price += 100
+product.update!
+```
+
+```ruby
+product = Product.find(conditions)
+product.add(price:100).put(authors:['Andy','Bob','Charlie']).update!
+```
+
+## 削除
+```ruby
+product = Product.find(conditions)
+product.add_expected(:price,10000).delete
+```
+
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/dymos/fork )
+1. Fork it ( https://github.com/hoshina85/dymos/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/dymos/client.rb

@@ -0,0 +1,16 @@
+require 'aws-sdk-core'
+
+module Dymos
+  class Client
+    attr_reader :client
+
+    def initialize(params={})
+      config = Aws.config.merge params
+      @client ||= Aws::DynamoDB::Client.new(config)
+    end
+
+    def command(name, params)
+      @client.send name, params
+    end
+  end
+end

data/lib/dymos/config.rb

@@ -0,0 +1,34 @@
+require 'aws-sdk-core'
+
+module Dymos
+  class Config
+
+    @default={
+      get_item: {},
+      create_table: {},
+      query: {},
+      scan: {},
+      put_item: {},
+      update_item: {},
+      describe_table: {},
+      delete_item: {},
+      batch_get_item: {},
+      batch_write_item: {},
+      delete_table: {},
+      list_tables: {},
+    }
+
+    class << self
+      attr_reader :default
+
+      def default=(config)
+        if Hash === config
+          @default = config
+        else
+          raise ArgumentError, 'configuration object must be a hash'
+        end
+      end
+    end
+
+  end
+end

data/lib/dymos/model.rb

@@ -7,8 +7,7 @@ module Dymos
     include ActiveModel::Dirty
     include ActiveModel::Callbacks
     include Dymos::Persistence
-    extend Dymos::Command
-    attr_accessor :metadata
+    attr_accessor :metadata, :last_execute_query
 
     define_model_callbacks :save
 
@@ -18,6 +17,36 @@ module Dymos
       super
     end
 
+    class << self
+      attr_accessor :last_execute_query
+
+      def method_missing(name, *args, &block)
+        methods ||= Dymos::Query::Query.instance_methods(false)+
+          Dymos::Query::GetItem.instance_methods(false)+
+          Dymos::Query::Scan.instance_methods(false)
+        if methods.include? name
+          @query||={}
+          @query[name]=args
+          self
+        else
+          super
+        end
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      methods ||= Dymos::Query::UpdateItem.instance_methods(false)+
+        Dymos::Query::PutItem.instance_methods(false)+
+        Dymos::Query::DeleteItem.instance_methods(false)
+      if methods.include? name
+        @query||={}
+        @query[name]=args
+        self
+      else
+        super
+      end
+    end
+
     def self.field(attr, type, default: nil, desc: nil)
       fail StandardError('attribute name is invalid') if attr =~ /[\!\?]$/
       fail StandardError('require "default" option') if (type == :bool && default.nil?)
@@ -32,18 +61,18 @@ module Dymos
       define_model_callbacks attr
       define_method(attr) { |raw=false|
         run_callbacks attr do
-        val = read_attribute(attr) || default
-        return val if raw || !val.present?
-        case type
-          when :bool
-            to_b(val)
-          when :time
-            Time.parse val
-          when :integer
-            val.to_i
-          else
-            val
-        end
+          val = read_attribute(attr) || default
+          return val if raw || !val.present?
+          case type
+            when :bool
+              to_b(val)
+            when :time
+              Time.parse val
+            when :integer
+              val.to_i
+            else
+              val
+          end
         end
 
       }
@@ -61,8 +90,8 @@ module Dymos
       define_model_callbacks :"set_#{attr}"
       define_method("#{attr}=") do |value, initialize=false|
         run_callbacks :"set_#{attr}" do
-        value = value.iso8601 if self.class.fields.include?(attr) && value.is_a?(Time)
-        write_attribute(attr, value, initialize)
+          value = value.iso8601 if self.class.fields.include?(attr) && value.is_a?(Time)
+          write_attribute(attr, value, initialize)
         end
       end
     end
@@ -71,7 +100,6 @@ module Dymos
       @fields
     end
 
-
     def self.table(name)
       define_singleton_method('table_name') { name }
       define_method('table_name') { name }
@@ -94,7 +122,21 @@ module Dymos
     end
 
     def self.all
-      self.scan.execute
+      if @query.present? && @query.keys & [:conditions, :add_condition, :where]
+        builder = Dymos::Query::Query.new.name(table_name)
+        @query.each do |k, v|
+          builder.send k, *v
+        end
+        @query={}
+      else
+        builder = Dymos::Query::Scan.new.name(table_name)
+      end
+      _execute(builder)
+    end
+
+    def self.one
+      @query[:limit] = 1
+      self.all.first
     end
 
     def self.find(key1, key2=nil)
@@ -102,19 +144,28 @@ module Dymos
       keys={}
       keys[indexes.first[:attribute_name].to_sym] = key1
       keys[indexes.last[:attribute_name].to_sym] = key2 if indexes.size > 1
-      self.get.key(keys).execute
+
+      builder = Dymos::Query::GetItem.new.name(table_name).key(keys)
+      _execute(builder)
+    end
+    def self._execute(builder)
+      query = builder.build
+      @last_execute_query = {command: builder.command, query: query}
+      response = Dymos::Client.new.command builder.command, query
+      to_model(class_name, response)
     end
 
     def self.key_scheme
-      @key_scheme ||= new.describe_table[:table][:key_schema]
+      @key_scheme ||= describe[:table][:key_schema]
     end
 
     def reload!
       reset_changes
     end
 
-    def describe_table
-      self.class.send(:describe).execute
+    def self.describe
+      builder=Dymos::Query::Describe.new.name(table_name)
+      Dymos::Client.new.command :describe_table, builder.build
     end
 
     def indexes
@@ -124,10 +175,6 @@ module Dymos
       scheme.to_h
     end
 
-    def dynamo
-      @client ||= Aws::DynamoDB::Client.new
-    end
-
     # @return [String]
     def self.class_name
       self.name
@@ -158,5 +205,41 @@ module Dymos
       end
     end
 
+    def self.to_model(class_name, res)
+      if class_name.present?
+        if res.data.respond_to? :items # scan, query
+          metadata = extract(res, :items)
+          res.data[:items].map do |datum|
+            obj = Object.const_get(class_name).new(datum)
+            obj.metadata = metadata
+            obj.new_record = false
+            obj
+          end
+        elsif res.data.respond_to? :attributes # put_item, update_item
+          return nil if res.attributes.nil?
+          obj = Object.const_get(class_name).new(res.attributes)
+          obj.metadata = extract(res, :attributes)
+          obj
+        elsif res.respond_to? :data
+          if res.data.respond_to? :item # get_item, delete_item
+            return nil if res.data.item.nil?
+            obj = Object.const_get(class_name).new(res.data.item)
+            obj.metadata = extract(res, :item)
+            obj.new_record = false
+            obj
+          else
+            res.data.to_hash # describe
+          end
+        end
+      else
+        res.data.to_hash #list_tables
+      end
+
+    end
+
+    def self.extract(res, ignore_key)
+      keys = res.data.members.reject { |a| a == ignore_key }
+      keys.map { |k| [k, res.data[k]] }.to_h
+    end
   end
 end

data/lib/dymos/persistence.rb

@@ -21,7 +21,7 @@ module Dymos
 
     def save(*)
       run_callbacks :save do
-        create_or_update
+        _put
       end
     rescue => e
       false
@@ -29,39 +29,98 @@ module Dymos
 
     def save!(*)
       run_callbacks :save do
-        create_or_update || raise(Dymos::RecordNotSaved)
+        _put || raise(Dymos::RecordNotSaved)
+      end
+    end
+
+    def update(*)
+      run_callbacks :save do
+        _update
+      end
+    rescue => e
+      false
+    end
+
+    def update!(*)
+      run_callbacks :save do
+        _update || raise(Dymos::RecordNotSaved)
       end
     end
 
     def delete
-      self.class.delete.key(indexes).execute if persisted?
+
+      if persisted?
+        builder = Dymos::Query::DeleteItem.new
+
+        builder.name(self.table_name).key(indexes).return_values(:all_old)
+
+        @query.each do |k, v|
+          builder.send k, *v
+        end if @query.present?
+        @query={}
+
+        query = builder.build
+        @last_execute_query = {command: builder.command, query: query}
+        Dymos::Client.new.command builder.command, query
+      end
       @destroyed = true
       freeze
     end
 
     private
 
-    def create_or_update
-      result = new_record? ? _create_record : _update_record
-      result != false
-    end
-
-    def _update_record()
+    def _put
+      send :created_at=, Time.new.iso8601 if respond_to? :created_at if @new_record
       send :updated_at=, Time.new.iso8601 if respond_to? :updated_at
-      _execute
+      builder = Dymos::Query::PutItem.new
+      builder.name(self.table_name).item(attributes).return_values(:all_old)
+
+      @query.each do |k, v|
+        builder.send k, *v
+      end if @query.present?
+      @query={}
+
+      _execute(builder)
     end
 
-    def _create_record()
-      send :created_at=, Time.new.iso8601 if respond_to? :created_at
+    def _update
       send :updated_at=, Time.new.iso8601 if respond_to? :updated_at
-      _execute
+      builder = Dymos::Query::UpdateItem.new
+
+      builder.name(self.table_name).key(indexes).return_values(:all_old)
+
+      self.changes.each do |column, change|
+        builder.put(column, change[1])
+      end
+
+      @query.each do |k, v|
+        builder.send k, *v
+      end if @query.present?
+      @query={}
+
+      _execute(builder)
     end
 
-    def _execute()
-      result = self.class.put.item(attributes).execute
+    #
+    # def _update_record()
+    #   send :updated_at=, Time.new.iso8601 if respond_to? :updated_at
+    #   _execute
+    # end
+    #
+    # def _create_record()
+    #   send :created_at=, Time.new.iso8601 if respond_to? :created_at
+    #   send :updated_at=, Time.new.iso8601 if respond_to? :updated_at
+    #   _execute
+    # end
+
+    def _execute(builder)
+      query = builder.build
+      @last_execute_query = {command: builder.command, query: query}
+      response = Dymos::Client.new.command builder.command, query
+      fail raise(Dymos::RecordNotSaved) if response.nil?
       changes_applied
       @new_record = false
-      result
+      response.present?
     end
 
   end

data/lib/dymos/query/base.rb

@@ -0,0 +1,23 @@
+module Dymos
+  module Query
+    class Base
+      def initialize
+        @query={}
+      end
+
+      def command
+
+      end
+
+      def name(value)
+        @query[:table_name] = value
+        self
+      end
+
+      def build(value={})
+        value = Dymos::Config.default[command.to_sym].merge value
+        @query.merge value
+      end
+    end
+  end
+end

data/lib/dymos/query/create_table.rb

@@ -0,0 +1,72 @@
+module Dymos
+  module Query
+    class CreateTable < Base
+      def command
+        'create_table'
+      end
+
+      def attributes(value)
+        @query[:attribute_definitions] = _attributes(value)
+        self
+      end
+
+      private def _attributes(value)
+        value.map { |k, v|
+          {attribute_name: k.to_s, attribute_type: v.to_s}
+        }
+      end
+
+      def keys(value)
+        @query[:key_schema]=_keys(value)
+        self
+      end
+
+      private def _keys(value)
+        value.map { |k, v|
+          {attribute_name: k.to_s, key_type: v.to_s}
+        }
+      end
+
+      def throughput(value)
+        @query[:provisioned_throughput] = _throughput(value)
+        self
+      end
+
+      private def _throughput(value)
+        {
+          read_capacity_units: value[:read],
+          write_capacity_units: value[:write]
+        }
+      end
+
+      def gsi(value)
+        @query[:global_secondary_indexes] = value.map { |i|
+          index = _index(i)
+          index[:provisioned_throughput] = _throughput(i[:throughput])
+          index
+        }
+        self
+      end
+
+      def lsi(value)
+        @query[:local_secondary_indexes] = value.map do |i|
+          _index(i)
+        end
+        self
+      end
+
+      private def _index(i)
+        index = {}
+        index[:index_name] = i[:name]
+        index[:key_schema] = _keys(i[:keys])
+        index[:projection]= _projection_type(i)
+        index[:projection][:non_key_attributes] = i[:projection][:attributes] if i.try(:[], :projection).try(:[], :attributes).present?
+        index
+      end
+
+      private def _projection_type(i)
+        {projection_type: (i.try(:[], :projection).try(:[], :type) || 'ALL').to_s}
+      end
+    end
+  end
+end

data/lib/dymos/query/delete_item.rb

@@ -1,47 +1,75 @@
 module Dymos
   module Query
-    class DeleteItem < ::Dymos::Query::Builder
+    class DeleteItem < Base
+      def command
+        'delete_item'
+      end
 
-      # @param [String] name
-      # @return [self]
-      def key(name)
-        @key = name
+      def key(value)
+        @query[:key] = value.deep_stringify_keys
         self
       end
 
-      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 expected(value)
+        value.map { |v| add_expected(*v) }
+        self
+      end
 
-        end]
+      def add_expected(*value)
+        if value.count == 2
+          column, operator, value = value[0], :eq, value[1]
+        else
+          column, operator, value = value
+        end
+        @query[:expected] ||= {}
+        @query[:expected].store(*_add_expected(column, operator, value))
         self
       end
 
-      def query
-        data = {
-            table_name: @table_name.to_s,
-            key: @key,
-            return_values: @return_values || 'ALL_OLD'
-        }
+      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
 
-        if @expected.present?
-          data[:expected] = @expected
-          if @expected.size > 1
-            data[:conditional_operator] = @conditional_operator || 'AND'
-          end
-        end
-        data
+      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 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/describe.rb

@@ -1,10 +1,8 @@
 module Dymos
   module Query
-    class Describe < ::Dymos::Query::Builder
-      def query
-        {
-            table_name: @table_name.to_s
-        }
+    class Describe < Base
+      def command
+        'describe_table'
       end
     end
   end