dynomite 1.2.6 → 2.0.0

data/lib/dynomite/item/write.rb

@@ -0,0 +1,204 @@
+class Dynomite::Item
+  module Write
+    extend ActiveSupport::Concern
+
+    # Not using method_missing to allow usage of dot notation and assign
+    # @attrs because it might hide actual missing methods errors.
+    # DynamoDB attrs can go many levels deep so it makes less make sense to
+    # use to dot notation.
+
+    def save(options={})
+      options.reverse_merge!(validate: true)
+      return self if options[:validate] && !valid?
+
+      action = new_record? ? :create : :update
+      run_callbacks(:save) do
+        run_callbacks(action) do
+          if action == :create
+            PutItem.call(self, options)
+          else # :update
+            call_update_strategy(options)
+          end
+        end
+      end
+    end
+
+    # Similar to save, but raises an error on failed validation.
+    def save!(options={})
+      raise_error_if_invalid
+      save(options)
+    end
+
+    # post.update(title: "test", body: "body")
+    # post.update({title: "test", body: "body"}, {validate: false})
+    def update(attrs={}, options={})
+      self.attrs.merge!(attrs)
+      options.reverse_merge!(validate: true)
+      return false if options[:validate] && !valid?
+
+      run_callbacks(:save) do
+        run_callbacks(:update) do
+          call_update_strategy(options)
+        end
+      end
+    end
+
+    def call_update_strategy(options)
+      if Dynomite.config.update_strategy == :update_item
+        # Note: fields assigned directly with brackets are not tracked as changed
+        # IE: post[:title] = "test"
+        UpdateItem.call(self, options)
+      else # default
+        PutItem.call(self, options)
+      end
+    end
+
+    # Similar to update, but raises an error on failed validation.
+    def update!(attrs={}, options={})
+      raise_error_if_invalid
+      update(attrs, options)
+    end
+
+    # When you add an item, the primary key attributes are the only required attributes.
+    # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#put_item-instance_method
+    def put(options={})
+      found_primary_keys = self.attrs.keys.map(&:to_s) & primary_key_fields
+      unless primary_key_fields.sort == found_primary_keys
+        raise Dynomite::Error::InvalidPut.new("Invalid put. The primary key fields #{primary_key_fields} must be present in the attrs #{attrs}")
+      end
+
+      options.reverse_merge!(validate: true)
+      return self if options[:validate] && !valid? # return self so can grab errors in invalid. save does the same thing
+
+      # Run callbacks for put so id is also set
+      run_callbacks(:save) do
+        run_callbacks(:update) do
+          PutItem.call(self, options.merge(put: true))
+        end
+      end
+    end
+    alias replace put
+
+    def put!(options={})
+      raise_error_if_invalid
+      put(options)
+    end
+    alias replace! put!
+
+    def destroy(options={})
+      run_callbacks(:destroy) do
+        DeleteItem.call(self, options)
+      end
+    end
+
+    def delete(options={})
+      DeleteItem.call(self, options)
+    end
+
+    attr_reader :_touching
+    def touch(*names, **options)
+      if new_record?
+        raise Dynomite::Error, 'cannot touch on a new item'
+      end
+
+      time_to_assign = options.delete(:time) || Time.now
+
+      self.updated_at = time_to_assign
+      names.each do |name|
+        attrs.send("#{name}=", time_to_assign)
+      end
+
+      @_touching = true
+      run_callbacks :touch do
+        UpdateItem.call(self, options)
+      end
+
+      self
+    end
+
+    # Examples:
+    #   user.increment(:likes)
+    #   user.increment(:likes, 2)
+    def increment(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] += by
+      self
+    end
+
+    # Increment counter. Validations and callbacks are skipped.
+    #
+    # Examples:
+    #
+    #   user.increment!(:likes)
+    #   user.increment!(:likes, 2)
+    #   user.increment!(:likes, touch: true)
+    #   user.increment!(:likes, touch: :created_at)
+    #   user.increment!(:likes, touch: [:viewed_at, :created_at])
+    #
+    def increment!(attribute, by = 1, touch: nil)
+      increment(attribute, by)
+
+      now = Time.now
+      attrs = Array(touch).inject({}) do |attrs, field|
+        attrs.merge!(field => now)
+      end if touch
+
+      run_callbacks :touch do
+        UpdateItem.new(self).save_changes(attrs: attrs, count_changes: { attribute => by })
+      end
+
+      self
+    end
+
+    # Example:
+    #
+    #   user = User.first
+    #   user.banned? # => false
+    #   user.toggle(:banned)
+    #   user.banned? # => true
+    #
+    def toggle(attribute)
+      self[attribute] = !public_send("#{attribute}?")
+      self
+    end
+
+    def toggle!(attribute)
+      toggle(attribute).update_attribute(attribute, self[attribute])
+    end
+
+    def raise_error_if_invalid
+      raise Dynomite::Error::Validation, "Validation failed: #{errors.full_messages.join(', ')}" unless valid?
+    end
+
+    class_methods do
+      def put(attrs={}, &block)
+        new(attrs, &block).put
+      end
+
+      def put!(attrs={}, &block)
+        new(attrs, &block).put!
+      end
+
+      def create(attrs={}, &block)
+        new(attrs, &block).save
+      end
+      alias create_with create
+
+      def create!(attrs={}, &block)
+        new(attrs, &block).save!
+      end
+
+      def find_or_create_by(attrs={})
+        find_by(attrs) || create(attrs)
+      end
+
+      def find_or_create_by!(attrs={})
+        find_by(attrs) || create!(attrs)
+      end
+
+      def find_or_initialize_by(attrs)
+        find_by(attrs) || new(attrs)
+      end
+    end
+  end
+end

data/lib/dynomite/item.rb

@@ -1,346 +1,160 @@
-require "active_support/core_ext/hash"
-require "aws-sdk-dynamodb"
+require "active_model"
 require "digest"
 require "yaml"
 
-require "dynomite/reserved_words"
-
-# The modeling is ActiveRecord-ish but not exactly because DynamoDB is a
-# different type of database.
+# The model is ActiveModel compatiable even though DynamoDB is a different type of database.
 #
 # Examples:
 #
-#   post = MyModel.new
-#   post = post.replace(title: "test title")
-#
-# post.attrs[:id] now contain a generaetd unique partition_key id.
-# Usually the partition_key is 'id'. You can set your own unique id also:
-#
-#   post = MyModel.new(id: "myid", title: "my title")
-#   post.replace
-#
-# Note that the replace method replaces the entire item, so you
-# need to merge the attributes if you want to keep the other attributes.
-#
-#   post = MyModel.find("myid")
-#   post.attrs = post.attrs.deep_merge("desc": "my desc") # keeps title field
-#   post.replace
+#   post = Post.new(id: "myid", title: "my title")
+#   post.save
 #
-# The convenience `attrs` method performs a deep_merge:
-#
-#   post = MyModel.find("myid")
-#   post.attrs("desc": "my desc") # <= does a deep_merge
-#   post.replace
-#
-# Note, a race condition edge case can exist when several concurrent replace
-# calls are happening.  This is why the interface is called replace to
-# emphasis that possibility.
-# TODO: implement post.update with db.update_item in a Ruby-ish way.
+# post.id now contain a generated unique partition_key id.
 #
 module Dynomite
   class Item
-    include Log
-    include DbConfig
-    include Errors
-
-    def initialize(attrs={})
-      @attrs = attrs
-    end
-
-    # Defining our own reader so we can do a deep merge if user passes in attrs
-    def attrs(*args)
-      case args.size
-      when 0
-        ActiveSupport::HashWithIndifferentAccess.new(@attrs)
-      when 1
-        attributes = args[0] # Hash
-        if attributes.empty?
-          ActiveSupport::HashWithIndifferentAccess.new
-        else
-          @attrs = attrs.deep_merge!(attributes)
+    class_attribute :fields_map
+    self.fields_map = {}
+    class_attribute :id_prefix_value
+
+    include Components
+    include Abstract
+    abstract!
+
+    # Must come after include Dynomite::Associations
+    def self.inherited(subclass)
+      subclass.id_prefix_value = subclass.name.underscore
+      # Not direct descendants of Dynomite::Item are abstract
+      # IE: SchemaMigration < Dynomite::Item
+      subclass.abstract! if subclass.name == "ApplicationItem"
+      subclass.class_attribute :fields_map
+      subclass.fields_map = {}
+      super # Dynomite::Associations.inherited
+    end
+
+    delegate :partition_key_field, :sort_key_field, to: :class
+    attr_reader :attrs
+    attr_accessor :new_record
+    alias_method :new_record?, :new_record
+    def initialize(attrs={}, &block)
+      run_callbacks(:initialize) do
+        @new_record = true
+        attrs = attrs.to_hash if attrs.respond_to?(:to_hash) # IE: ActionController::Parameters
+        raise ArgumentError, "attrs must be a Hash. attrs is a #{attrs.class}" unless attrs.is_a?(Hash)
+        @attrs = ActiveSupport::HashWithIndifferentAccess.new(attrs)
+        attrs.each do |k,v|
+          send("#{k}=", v) if respond_to?("#{k}=") # so typecasting happens
         end
-      end
-    end
-
-    # Not using method_missing to allow usage of dot notation and assign
-    # @attrs because it might hide actual missing methods errors.
-    # DynamoDB attrs can go many levels deep so it makes less make sense to
-    # use to dot notation.
-
-    # The method is named replace to clearly indicate that the item is
-    # fully replaced.
-    def replace(hash={})
-      @attrs = @attrs.deep_merge(hash)
+        @associations = {}
 
-      # valid? method comes from ActiveModel::Validations
-      if respond_to? :valid?
-        return false unless valid?
+        if block
+          yield(self)
+        end
       end
-
-      attrs = self.class.replace(@attrs)
-
-      @attrs = attrs # refresh attrs because it now has the id
-      self
     end
 
-    # Similar to replace, but raises an error on failed validation.
-    # Works that way only if ActiveModel::Validations are included
-    def replace!(hash={})
-      raise ValidationError, "Validation failed: #{errors.full_messages.join(', ')}" unless replace(hash)
+    # Keeps the current attrs
+    def attrs=(attrs)
+      @attrs.deep_merge!(attrs)
     end
 
-    def find(id)
-      self.class.find(id)
-    end
-
-    def delete
-      self.class.delete(@attrs[:id]) if @attrs[:id]
-    end
-
-    def table_name
-      self.class.table_name
-    end
-
-    def partition_key
-      self.class.partition_key
-    end
-
-    # For render json: item
-    def as_json(options={})
-      @attrs
-    end
-
-    # Longer hand methods for completeness.
-    # Internallly encourage the shorter attrs method.
-    def attributes=(attributes)
-      @attributes = attributes
-    end
-
-    def attributes
-      @attributes
-    end
-
-    # Adds very little wrapper logic to scan.
-    #
-    # * Automatically add table_name to options for convenience.
-    # * Decorates return value.  Returns Array of [MyModel.new] instead of the
-    #   dynamodb client response.
-    #
-    # Other than that, usage is same was using the dynamodb client scan method
-    # directly.  Example:
-    #
-    #   MyModel.scan(
-    #     expression_attribute_names: {"#updated_at"=>"updated_at"},
-    #     filter_expression: "#updated_at between :start_time and :end_time",
-    #     expression_attribute_values: {
-    #       ":start_time" => "2010-01-01T00:00:00",
-    #       ":end_time" => "2020-01-01T00:00:00"
-    #     }
-    #   )
-    #
-    # AWS Docs examples: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Ruby.04.html
-    def self.scan(params={})
-      log("It's recommended to not use scan for production. It can be slow and expensive. You can a LSI or GSI and query the index instead.")
-      log("Scanning table: #{table_name}")
-      params = { table_name: table_name }.merge(params)
-      resp = db.scan(params)
-      resp.items.map {|i| self.new(i) }
-    end
+    # Longer hand methods for completeness. Internally encourage shorter attrs.
+    alias_method :attributes=, :attrs=
+    alias_method :attributes, :attrs
 
-    # Adds very little wrapper logic to query.
-    #
-    # * Automatically add table_name to options for convenience.
-    # * Decorates return value.  Returns Array of [MyModel.new] instead of the
-    #   dynamodb client response.
+    # Because using `define_attribute_methods *names` as part of `add_field` dsl.
+    # Found that define_attribute_methods is required for dirty support.
+    # This adds missing_attribute method that will look for a method called attribute.
+    #   send(match.target, match.attr_name, *args, &block)
+    #   send(:attribute, :my_column)
+    # The error message when an attribute is not found is more helpful when this is defined.
     #
-    # Other than that, usage is same was using the dynamodb client query method
-    # directly.  Example:
-    #
-    #   MyModel.query(
-    #     index_name: 'category-index',
-    #     expression_attribute_names: { "#category_name" => "category" },
-    #     expression_attribute_values: { ":category_value" => "Entertainment" },
-    #     key_condition_expression: "#category_name = :category_value",
-    #   )
-    #
-    # AWS Docs examples: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Ruby.04.html
-    def self.query(params={})
-      params = { table_name: table_name }.merge(params)
-      resp = db.query(params)
-      resp.items.map {|i| self.new(i) }
+    # It looks confusing that we always raise an error for attribute because fields must
+    # be defined to access them through dot notation. This is because users to
+    # explicitly define fields and access undeclared fields with hash notation [],
+    # read_attribute, or attributes.
+    def attribute(name)
+      raise NoMethodError, "undefined method '#{name}' for #{self.class}"
     end
 
-    # Translates simple query searches:
-    #
-    #   Post.where({category: "Drama"}, index_name: "category-index")
-    #
-    # translates to
-    #
-    #   resp = db.query(
-    #     table_name: "demo-dev-post",
-    #     index_name: 'category-index',
-    #     expression_attribute_names: { "#category_name" => "category" },
-    #     expression_attribute_values: { ":category_value" => category },
-    #     key_condition_expression: "#category_name = :category_value",
-    #   )
-    #
-    # TODO: Implement nicer where syntax with index_name as a chained method.
-    #
-    #   Post.where({category: "Drama"}, {index_name: "category-index"})
-    #     VS
-    #   Post.where(category: "Drama").index_name("category-index")
-    def self.where(attributes, options={})
-      raise "attributes.size == 1 only supported for now" if attributes.size != 1
-
-      attr_name = attributes.keys.first
-      attr_value = attributes[attr_name]
-
-      # params = {
-      #   expression_attribute_names: { "#category_name" => "category" },
-      #   expression_attribute_values: { ":category_value" => "Entertainment" },
-      #   key_condition_expression: "#category_name = :category_value",
-      # }
-      name_key, value_key = "##{attr_name}_name", ":#{attr_name}_value"
-      params = {
-        expression_attribute_names: { name_key => attr_name },
-        expression_attribute_values: { value_key => attr_value },
-        key_condition_expression: "#{name_key} = #{value_key}",
-      }
-      # Allow direct access to override params passed to dynamodb query options.
-      # This is is how index_name is passed:
-      params = params.merge(options)
-
-      query(params)
+    def read_attribute(field)
+      @attrs[field.to_sym]
     end
 
-    def self.replace(attrs)
-      # Automatically adds some attributes:
-      #   partition key unique id
-      #   created_at and updated_at timestamps. Timestamp format from AWS docs: http://amzn.to/2z98Bdc
-      defaults = {
-        partition_key => Digest::SHA1.hexdigest([Time.now, rand].join)
-      }
-      item = defaults.merge(attrs)
-      item["created_at"] ||= Time.now.utc.strftime('%Y-%m-%dT%TZ')
-      item["updated_at"] = Time.now.utc.strftime('%Y-%m-%dT%TZ')
-
-      # put_item full replaces the item
-      resp = db.put_item(
-        table_name: table_name,
-        item: item
-      )
-
-      # The resp does not contain the attrs. So might as well return
-      # the original item with the generated partition_key value
-      item
+    # Only updates in memory, does not save to database.
+    # Same as ActiveRecord behavior.
+    def write_attribute(field, value)
+      @attrs[field.to_sym] = value
     end
 
-    def self.find(id)
-      params =
-        case id
-        when String
-          { partition_key => id }
-        when Hash
-          id
-        end
-
-      resp = db.get_item(
-        table_name: table_name,
-        key: params
-      )
-      attributes = resp.item # unwraps the item's attributes
-      self.new(attributes) if attributes
+    def update_attribute(field, value)
+      write_attribute(field, value)
+      update(@attrs, {validate: false})
+      valid? # ActiveRecord return value behavior
     end
 
-    # Two ways to use the delete method:
-    #
-    # 1. Specify the key as a String. In this case the key will is the partition_key
-    # set on the model.
-    #   MyModel.delete("728e7b5df40b93c3ea6407da8ac3e520e00d7351")
-    #
-    # 2. Specify the key as a Hash, you can arbitrarily specific the key structure this way
-    # MyModel.delete("728e7b5df40b93c3ea6407da8ac3e520e00d7351")
-    #
-    # options is provided in case you want to specific condition_expression or
-    # expression_attribute_values.
-    def self.delete(key_object, options={})
-      if key_object.is_a?(String)
-        key = {
-          partition_key => key_object
-        }
-      else # it should be a Hash
-        key = key_object
-      end
-
-      params = {
-        table_name: table_name,
-        key: key
-      }
-      # In case you want to specify condition_expression or expression_attribute_values
-      params = params.merge(options)
-
-      resp = db.delete_item(params)
+    def delete_attribute(field)
+      @attrs.delete(field.to_sym)
+      update(@attrs, {validate: false})
+      valid? # ActiveRecord does not have a delete_attribute. Follow update_attribute behavior.
     end
+    alias :remove_attribute :delete_attribute
 
-    # When called with an argument we'll set the internal @partition_key value
-    # When called without an argument just retun it.
-    # class Comment < Dynomite::Item
-    #   partition_key "post_id"
-    # end
-    def self.partition_key(*args)
-      case args.size
-      when 0
-        @partition_key || "id" # defaults to id
-      when 1
-        @partition_key = args[0].to_s
+    def update_attribute_presence(field, value)
+      if value.present?
+        update_attribute(field, value)
+      else # nil or empty string or empty array
+        delete_attribute(field)
       end
     end
 
-    def self.table_name(*args)
-      case args.size
-      when 0
-        get_table_name
-      when 1
-        set_table_name(args[0])
-      end
+    def [](field)
+      read_attribute(field)
     end
 
-    def self.get_table_name
-      @table_name ||= self.name.pluralize.gsub('::','-').underscore.dasherize
-      [table_namespace, @table_name].reject {|s| s.nil? || s.empty?}.join('-')
+    def []=(field, value)
+      write_attribute(field, value)
     end
 
-    def self.set_table_name(value)
-      @table_name = value
+    # For render json: item
+    def as_json(options={})
+      @attrs
     end
 
-    def self.table
-      Aws::DynamoDB::Table.new(name: table_name, client: db)
+    # Required for ActiveModel
+    def persisted?
+      !new_record?
     end
 
-    def self.count
-      table.item_count
+    def reload
+      if persisted?
+        id = @attrs[partition_key_field]
+        item = if sort_key_field
+                 find(partition_key_field => id, sort_key_field => @attrs[sort_key_field])
+               else
+                 find(id) # item has different object_id
+               end
+        @attrs = item.attrs # replace current loaded attributes
+      end
+      self
     end
 
-    # Defines column. Defined column can be accessed by getter and setter methods of the same
-    # name (e.g. [model.my_column]). Attributes with undefined columns can be accessed by
-    # [model.attrs] method.
-    def self.column(*names)
-      names.each(&method(:add_column))
+    # p1 = Product.first
+    # p2 = Product.first
+    # p1 == p2 # => true
+    #
+    # p1 = Product.first
+    # products = Product.all
+    # products.include?(p1) # => true
+    def ==(other)
+      self.class == other.class && self.attrs == other.attrs
     end
 
-    # @see Item.column
-    def self.add_column(name)
-      if Dynomite::RESERVED_WORDS.include?(name)
-        raise ReservedWordError, "'#{name}' is a reserved word"
-      end
-
-      define_method(name) do
-        @attrs[name.to_s]
-      end
-
-      define_method("#{name}=") do |value|
-        @attrs[name.to_s] = value
+    def to_param
+      if id
+        id
+      else
+        raise "Need to define a id field for to_param"
       end
     end
   end

data/lib/dynomite/migration/dsl/accessor.rb

@@ -0,0 +1,19 @@
+class Dynomite::Migration::Dsl
+  module Accessor
+    def dsl_accessor(*names)
+      names.each do |name|
+        define_dsl_accessor(name)
+      end
+    end
+
+    def define_dsl_accessor(name)
+      define_method(name) do |*args|
+        if args.empty?
+          instance_variable_get("@#{name}")
+        else
+          instance_variable_set("@#{name}", args.first)
+        end
+      end
+    end
+  end
+end