@wip Implement class method delete()

Author: andrykonchin

lib/dynamoid/persistence.rb

@@ -455,6 +455,90 @@ def inc(hash_key_value, range_key_value = nil, counters)
         Inc.call(self, hash_key_value, range_key_value, counters)
         self
       end
+
+      # Delete a model.
+      #
+      # Delete a model by given partition key:
+      #
+      #   User.delete(user_id)
+      #
+      # Delete a model by given partition and sort keys:
+      #
+      #   User.delete(user_id, sort_key)
+      #
+      # Delete multiple models by given partition keys:
+      #
+      #   User.delete([id1, id2, id3])
+      #
+      # Delete multiple models by given partition and sort keys:
+      #
+      #   User.delete([[id1, sk1], [id2, sk2], [id3, sk3]])
+      #
+      # Raises +Dynamoid::Errors::MissingHashKey+ if a partition key has value
+      # +nil+ and raises +Dynamoid::Errors::MissingRangeKey+ if a sort key is
+      # required but has value +nil+ or is missing.
+      #
+      # @return nil
+      def delete(*args)
+        if args.empty?
+          raise Dynamoid::Errors::MissingHashKey
+        end
+
+        # TODO: warn if passed excessive arguments
+        # TODO: handle a case when sort key isn't declared but given in arguments
+        if args[0].is_a?(Array)
+          # given multiple keys:
+          keys = args[0] # ignore other arguments
+
+
+          if keys[0].is_a?(Array)
+            # compound primary key
+
+            ids = []
+            range_key = []
+
+            # assume all elements are pairs, that's arrays
+            keys.each do |pk, sk|
+              raise Dynamoid::Errors::MissingHashKey if pk.nil?
+              raise Dynamoid::Errors::MissingRangeKey if self.range_key? && sk.nil?
+
+              partition_key_dumped = Dumping.dump_field(pk, self.attributes[self.hash_key])
+              sort_key_dumped = Dumping.dump_field(sk, self.attributes[self.range_key])
+
+              ids << partition_key_dumped
+              range_key << sort_key_dumped
+            end
+          else
+            # simple primary key
+
+            ids = []
+            range_key = nil
+
+            keys.each do |pk|
+              raise Dynamoid::Errors::MissingHashKey if pk.nil?
+
+              partition_key_dumped = Dumping.dump_field(pk, self.attributes[self.hash_key])
+              ids << partition_key_dumped
+            end
+          end
+
+          options = range_key ? { range_key: range_key } : {}
+          Dynamoid.adapter.delete(self.table_name, ids, options)
+        else
+          # Model.delete(partition_key, sort_key)
+          partition_key, sort_key = args
+
+          raise Dynamoid::Errors::MissingHashKey if partition_key.nil?
+          raise Dynamoid::Errors::MissingRangeKey if self.range_key? && sort_key.nil?
+
+          options = sort_key ? { range_key: Dumping.dump_field(sort_key, self.attributes[self.range_key]) } : {}
+          partition_key_dumped = Dumping.dump_field(partition_key, self.attributes[self.hash_key])
+
+          Dynamoid.adapter.delete(self.table_name, partition_key_dumped, options)
+        end
+
+        nil
+      end
     end
 
     # Update document timestamps.

spec/dynamoid/persistence/delete_spec.rb

@@ -4,7 +4,121 @@
 require 'fixtures/persistence'
 
 RSpec.describe Dynamoid::Persistence do
-  describe 'delete' do
+  describe '.delete' do
+    let(:klass_with_composite_key) do
+      new_class do
+        range :age, :integer
+        field :name
+      end
+    end
+
+    it 'deletes an item' do
+      klass = new_class
+      obj = klass.create!
+
+      expect { klass.delete(obj.id) }.to change { klass.exists? obj.id }.from(true).to(false)
+    end
+
+    it 'deletes multiple items when given multiple partition keys' do
+      klass = new_class
+      obj1 = klass.create!
+      obj2 = klass.create!
+
+      klass.delete([obj1.id, obj2.id])
+
+      expect(klass.exists?(obj1.id)).to eql(false)
+      expect(klass.exists?(obj2.id)).to eql(false)
+    end
+
+    it 'deletes multiple items when given multiple partition and sort keys' do
+      obj1 = klass_with_composite_key.create!(age: 1)
+      obj2 = klass_with_composite_key.create!(age: 2)
+
+      klass_with_composite_key.delete([[obj1.id, obj1.age], [obj2.id, obj2.age]])
+
+      expect(klass_with_composite_key.exists?([[obj1.id, obj1.age]])).to eql(false)
+      expect(klass_with_composite_key.exists?([[obj2.id, obj2.age]])).to eql(false)
+    end
+
+    it 'uses dumped value of partition key to delete item' do
+      klass = new_class(partition_key: { name: :published_on, type: :date })
+
+      obj = klass.create!(published_on: '2018-10-07'.to_date)
+
+      expect {
+        klass.delete(obj.published_on)
+      }.to change {
+        klass.where(published_on: obj.published_on).first
+      }.to(nil)
+    end
+
+    it 'uses dumped value of sort key to delete item' do
+      klass = new_class do
+        range :activated_on, :date
+      end
+
+      obj = klass.create!(activated_on: Date.today)
+
+      expect {
+        klass.delete(obj.id, obj.activated_on)
+      }.to change {
+        klass.where(id: obj.id, activated_on: obj.activated_on).first
+      }.to(nil)
+    end
+
+    it 'does not raise exception when model was concurrently deleted' do
+      klass = new_class
+      klass.create_table
+
+      expect(klass.delete("not-existing-id")).to eql(nil)
+    end
+
+    describe 'primary key validation' do
+      context 'simple primary key' do
+        it 'requires partition key to be specified' do
+          klass = new_class
+          expect { klass.delete(nil) }.to raise_exception(Dynamoid::Errors::MissingHashKey)
+        end
+      end
+
+      context 'composite key' do
+        it 'requires partition key to be specified' do
+          expect { klass_with_composite_key.delete(nil, 1) }.to raise_exception(Dynamoid::Errors::MissingHashKey)
+        end
+
+        it 'requires sort key to be specified' do
+          expect { klass_with_composite_key.delete("abc", nil) }.to raise_exception(Dynamoid::Errors::MissingRangeKey)
+          expect { klass_with_composite_key.delete("abc") }.to raise_exception(Dynamoid::Errors::MissingRangeKey)
+        end
+      end
+    end
+
+    context 'when table arn is specified', remove_constants: [:Payment] do
+      it 'uses given table ARN in requests instead of a table name', config: { create_table_on_save: false } do
+        # Create table manually because CreateTable doesn't accept ARN as a
+        # table name. Add namespace to have this table removed automativally.
+        table_name = :"#{Dynamoid::Config.namespace}_purchases"
+        Dynamoid.adapter.create_table(table_name, :id)
+
+        table = Dynamoid.adapter.describe_table(table_name)
+        expect(table.arn).to be_present
+
+        Payment = Class.new do # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+          include Dynamoid::Document
+
+          table arn: table.arn
+        end
+
+        payment = Payment.create!
+
+        expect {
+          Payment.delete(payment.id)
+        }.to send_request_matching(:DeleteItem, { TableName: table.arn })
+      end
+    end
+  end
+
+  describe '#delete' do
     let(:klass_with_composite_key) do
       new_class do
         range :age, :integer