feat: add softDelete

src/DataMapper/DataMapper.php

@@ -2,8 +2,10 @@
 
 namespace Mongolid\DataMapper;
 
+use DateTime;
 use InvalidArgumentException;
 use MongoDB\BSON\ObjectId;
+use MongoDB\BSON\UTCDateTime;
 use MongoDB\Collection;
 use Mongolid\Container\Container;
 use Mongolid\Cursor\CursorInterface;
@@ -17,6 +19,7 @@
 use Mongolid\Schema\Schema;
 use Mongolid\Util\ObjectIdUtils;
 use Mongolid\Connection\Connection;
+Use Mongolid\Util\SoftDeleteQueries;
 
 /**
  * The DataMapper class will abstract how an Entity is persisted and retrieved
@@ -221,6 +224,11 @@ public function update($entity, array $options = []): bool
      */
     public function delete($entity, array $options = []): bool
     {
+        if ($entity->enabledSoftDeletes ?? false) {
+            return $this->executeSoftDelete($entity, $options);
+        }
+
+
         if (false === $this->fireEvent('deleting', $entity, true)) {
             return false;
         }
@@ -259,13 +267,14 @@ public function where(
         $cursorClass = $cacheable ? SchemaCacheableCursor::class : SchemaCursor::class;
 
         $model = new $this->schema->entityClass;
+        $query =   $this->prepareValueQuery($query);
 
         return new $cursorClass(
             $this->schema,
             $this->getCollection(),
             'find',
             [
-                $this->prepareValueQuery($query),
+                SoftDeleteQueries::insertFilterForSoftDelete($query, $model),
                 [
                     'projection' => $this->prepareProjection($projection),
                     'eagerLoads' => $model->with ?? [],
@@ -302,8 +311,11 @@ public function first(
             return $this->where($query, $projection, true)->first();
         }
 
+        $model = new $this->schema->entityClass;
+        $query =   $this->prepareValueQuery($query);
+
         $document = $this->getCollection()->findOne(
-            $this->prepareValueQuery($query),
+            SoftDeleteQueries::insertFilterForSoftDelete($query, $model),
             ['projection' => $this->prepareProjection($projection)]
         );
 
@@ -665,4 +677,12 @@ function ($value) {
 
         return $filtered;
     }
+
+    private function executeSoftDelete(ModelInterface $entity, $options): bool
+    {
+        $deletedAtCoullum = SoftDeleteQueries::getDeletedAtColumn($entity);
+        $entity->$deletedAtCoullum = new UTCDateTime(new DateTime('now'));
+
+        return $this->update($entity, $options);
+    }
 }

src/Model/SoftDeletesTrait.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Mongolid\Model;
+
+trait SoftDeletesTrait
+{
+    public $enabledSoftDeletes = true;
+
+    public function isTrashed(): bool
+    {
+        return !is_null($this->{$this->getDeletedAtColumn()});
+    }
+
+    public function restore(): bool
+    {
+        $collumn = $this->getDeletedAtColumn();
+
+        if (!$this->{$collumn}) {
+            return false;
+        }
+
+        $this->{$collumn} = null;
+
+        return $this->execute('save');
+    }
+
+    public function forceDelete(): bool
+    {
+        $this->forceDelete = true;
+
+        return $this->execute('delete');
+    }
+
+    private function getDeletedAtColumn(): string
+    {
+        return defined(
+            static::class . '::DELETED_AT'
+        )
+            ? static::DELETED_AT
+            : 'deleted_at';
+    }
+}

src/Util/SoftDeleteQueries.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Mongolid\Util;
+
+use Mongolid\Model\ModelInterface;
+
+class SoftDeleteQueries
+{
+    public static function insertFilterForSoftDelete(array $query, ModelInterface $model): array
+    {
+        $field = self::getDeletedAtColumn($model);
+
+        return array_merge(
+            $query,
+            [
+                '$or' => [
+                    [
+                        $field => null,
+                    ],
+                    [
+                        $field => ['$exists' => false],
+                    ],
+                ],
+            ]
+        );
+    }
+
+    public static function getDeletedAtColumn(ModelInterface $model): string
+    {
+        return defined(
+            $model::class . '::DELETED_AT'
+        )
+            ? $model::DELETED_AT
+            : 'deleted_at';
+    }
+}

tests/Integration/PersisteModelWithSoftDeleteTest.php

@@ -0,0 +1,153 @@
+<?php
+
+namespace Mongolid\Tests\Integration;
+
+use DateTime;
+use MongoDB\BSON\ObjectId;
+use MongoDB\BSON\UTCDateTime;
+use Mongolid\Model\ModelInterface;
+use Mongolid\Tests\Stubs\Product;
+use Mongolid\Tests\Stubs\ProductWithSoftDelete;
+
+final class PersisteModelWithSoftDeleteTest extends IntegrationTestCase
+{
+    private ObjectId $_id;
+
+    public function testFindNotDeletedProduct(): void
+    {
+        // Set
+        $product = $this->persiteProduct();
+
+        // Actions
+        $result = ProductWithSoftDelete::where()->first();
+
+        // Assertion
+        $this->assertEquals($product, $result);
+    }
+
+    public function testCannotFindDeletedProduct(): void
+    {
+        // Set
+        $this->persiteProduct(true);
+
+        // Actions
+        $result = ProductWithSoftDelete::where()->first();
+
+        // Assertion
+        $this->assertNull($result);
+    }
+
+    public function testFindDeletedProductWithFirst(): void
+    {
+        // Set
+        $product = $this->persiteProduct();
+
+        // Actions
+        $result = ProductWithSoftDelete::first($this->_id);
+
+        // Assertion
+        $this->assertEquals($product, $result);
+    }
+
+    public function testCannotFindDeletedProductWithFirst(): void
+    {
+        // Set
+        $this->persiteProduct(true);
+
+        // Actions
+        $result = ProductWithSoftDelete::first($this->_id);
+
+        // Assertion
+        $this->assertNull($result);
+    }
+
+    public function testRestoreDeletedProduct(): void
+    {
+        // Set
+        $product = $this->persiteProduct(true);
+
+        // Actions
+        $isRestored = $product->restore();
+        $result = ProductWithSoftDelete::first($this->_id);
+
+        // Assertion
+        $this->assertTrue($isRestored);
+        $this->assertEquals($product, $result);
+    }
+
+    public function testCannotRestoreAlreadyRestoredProduct(): void
+    {
+        // Set
+        $product = $this->persiteProduct(isRestored: true);
+
+        // Actions
+        $isRestored = $product->restore();
+        $result = ProductWithSoftDelete::first($this->_id);
+
+        // Assertion
+        $this->assertFalse($isRestored);
+        $this->assertEquals($product, $result);
+    }
+
+    public function testExecuteSoftDeleteOnProduct(): void
+    {
+        // Set
+        $product = $this->persiteProduct();
+
+        // Actions
+         $isDeleted = $product->delete();
+         $result = ProductWithSoftDelete::first($this->_id);
+
+        // Assertion
+        $this->assertTrue($isDeleted);
+        $this->assertNull($result);
+        $this->assertInstanceOf(UTCDateTime::class, $product->deleted_at);
+    }
+
+    public function testCannotExecuteSoftDeleteOnProduct(): void
+    {
+        // Set
+        $product = $this->persiteProduct(model:Product::class);
+
+        // Actions
+         $isDeleted = $product->delete();
+         $result = ProductWithSoftDelete::first($this->_id);
+
+        // Assertion
+        $this->assertTrue($isDeleted);
+        $this->assertNull($result);
+        $this->assertNull($result->deleted_at ?? null);
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->_id = new ObjectId('5bcb310783a7fcdf1bf1a672');
+    }
+
+    private function persiteProduct(
+        bool $softDeleted = false,
+        bool $isRestored = false,
+        string $model = ProductWithSoftDelete::class
+    ): ModelInterface {
+        $product = new $model();
+        $product->_id = $this->_id;
+        $product->short_name = 'Furadeira de Impacto Bosch com Chave de Mandril ';
+        $product->name = 'Furadeira de Impacto Bosch com Chave de Mandril e Acessórios 550W 1/2 GSB 550 RE 127V (110V)';
+
+        if ($softDeleted) {
+            $date = new UTCDateTime(new DateTime('today'));
+
+            $product->deleted_at = $date;
+        }
+
+        if ($isRestored) {
+            $product->deleted_at = null;
+        }
+
+        $product->save();
+
+        return $product;
+    }
+}

tests/Stubs/ProductWithSoftDelete.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Mongolid\Tests\Stubs;
+
+use Mongolid\Model\SoftDeletesTrait;
+
+class ProductWithSoftDelete extends Product
+{
+    use SoftDeletesTrait;
+}

tests/Unit/Model/SoftDeletesTraitTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Mongolid\Model;
+
+use DateTime;
+use MongoDB\BSON\UTCDateTime;
+use Mongolid\DataMapper\DataMapper;
+use Mongolid\Schema\DynamicSchema;
+use Mongolid\TestCase;
+use Mongolid\Tests\Stubs\Product;
+use Mockery as m;
+use Mongolid\Tests\Stubs\ProductWithSoftDelete;
+
+class SoftDeletesTraitTest extends TestCase
+{
+    public function testShouldReturnStatusOfSoftDelete(): void
+    {
+        // Set
+        $date = new UTCDateTime(new DateTime('today'));
+        $product = new ProductWithSoftDelete();
+        $product->deleted_at = $date;
+
+        // Actions
+        $actual = $product->isTrashed();
+
+        // Assertions
+        $this->assertTrue($actual);
+    }
+
+    public function testShouldRestoreProduct(): void
+    {
+        // Set
+        $product = new ProductWithSoftDelete();
+        $date = new UTCDateTime(new DateTime('today'));
+        $product->deleted_at = $date;
+        $dataMapper = $this->instance(
+            DataMapper::class,
+            m::mock(DataMapper::class)
+        );
+
+        // Expectations
+        $dataMapper->expects()
+            ->setSchema(m::type(DynamicSchema::class));
+
+        $dataMapper->expects()
+            ->save(m::type(Product::class), m::type('array'))
+            ->andReturnTrue();
+
+        // Actions
+        $actual = $product->restore();
+
+        // Assertions
+        $this->assertTrue($actual);
+    }
+
+    public function testShouldNotRestoreProduct(): void
+    {
+        // Set
+        $product = new ProductWithSoftDelete();
+
+        // Actions
+        $actual = $product->restore();
+
+        // Assertions
+        $this->assertFalse($actual);
+    }
+}