keep track of removed aggregates to reduce the number of operations inside a filesystem transaction

Author: Baptouuuu

src/Adapter/Filesystem/Repository.php

@@ -93,9 +93,7 @@ public function add(Aggregate $data): Attempt
             ($this->encode)($data),
         );
 
-        return $this->transaction->mutate(
-            static fn($adapter) => $adapter->add($encoded),
-        );
+        return $this->transaction->mutate($encoded);
     }
 
     #[\Override]
@@ -105,9 +103,7 @@ public function update(Diff $data): Attempt
             ($this->encode)($data),
         );
 
-        return $this->transaction->mutate(
-            static fn($adapter) => $adapter->add($encoded),
-        );
+        return $this->transaction->mutate($encoded);
     }
 
     #[\Override]
@@ -136,9 +132,7 @@ public function remove(Aggregate\Id $id): Attempt
             Name::of($id->value()),
         );
 
-        return $this->transaction->mutate(
-            static fn($adapter) => $adapter->add($mutated),
-        );
+        return $this->transaction->mutate($mutated);
     }
 
     #[\Override]

src/Adapter/Filesystem/Transaction.php

@@ -12,6 +12,8 @@
 use Innmind\Immutable\{
     Attempt,
     Sequence,
+    Map,
+    Set,
     SideEffect,
     Predicate\Instance,
 };
@@ -22,13 +24,18 @@
 final class Transaction implements TransactionInterface
 {
     private Adapter $committed;
-    /** @var Sequence<callable(Adapter): Attempt<SideEffect>> */
+    private Adapter $notCommitted;
+    /** @var Sequence<Directory> */
     private Sequence $mutations;
+    /** @var Map<non-empty-string, Set<Name>> */
+    private Map $removals;
 
     private function __construct(Adapter $committed)
     {
         $this->committed = $committed;
+        $this->notCommitted = Adapter::inMemory();
         $this->mutations = Sequence::of();
+        $this->removals = Map::of();
     }
 
     /**
@@ -42,7 +49,7 @@ public static function of(Adapter $committed): self
     #[\Override]
     public function start(): Attempt
     {
-        $this->mutations = $this->mutations->clear();
+        $this->reset();
 
         return Attempt::result(SideEffect::identity());
     }
@@ -59,7 +66,7 @@ public function commit(mixed $value): Attempt
     {
         return $this
             ->apply($this->committed)
-            ->map(fn() => $this->mutations = $this->mutations->clear())
+            ->map($this->reset(...))
             ->map(static fn() => $value);
     }
 
@@ -73,49 +80,66 @@ public function commit(mixed $value): Attempt
     #[\Override]
     public function rollback(mixed $value): Attempt
     {
-        $this->mutations = $this->mutations->clear();
+        $this->reset();
 
         return Attempt::result($value);
     }
 
     /**
-     * @param callable(Adapter): Attempt<SideEffect> $mutate
-     *
      * @return Attempt<SideEffect>
      */
-    public function mutate(callable $mutate): Attempt
+    public function mutate(Directory $directory): Attempt
     {
-        $this->mutations = ($this->mutations)($mutate);
-
-        return Attempt::result(SideEffect::identity);
+        $this->mutations = ($this->mutations)($directory);
+        /** @psalm-suppress InternalMethod */
+        $this->removals = ($this->removals)(
+            $directory->name()->toString(),
+            $this
+                ->removals
+                ->get($directory->name()->toString())
+                ->match(
+                    static fn($removed) => $removed->merge($directory->removed()),
+                    static fn() => $directory->removed(),
+                ),
+        );
+
+        return $this->notCommitted->add($directory);
     }
 
     public function get(Name $directory): Directory
     {
-        $committed = $this
-            ->committed
+        $notCommitted = $this
+            ->notCommitted
             ->get($directory)
             ->keep(Instance::of(Directory::class))
             ->match(
                 static fn($directory) => $directory,
                 static fn() => Directory::of($directory),
             );
-        $notCommitted = Adapter::inMemory();
-        $_ = $notCommitted
-            ->add($committed)
-            ->unwrap();
-
-        $_ = $this
-            ->apply($notCommitted)
-            ->unwrap();
-
-        return $notCommitted
+        $committed = $this
+            ->committed
             ->get($directory)
             ->keep(Instance::of(Directory::class))
             ->match(
                 static fn($directory) => $directory,
                 static fn() => Directory::of($directory),
             );
+
+        $merged = $this
+            ->removals
+            ->get($directory->toString())
+            ->match(
+                static fn($removed) => $removed->reduce(
+                    $committed,
+                    static fn(Directory $committed, $name) => $committed->remove($name),
+                ),
+                static fn() => $committed,
+            );
+
+        return $notCommitted->all()->reduce(
+            $merged,
+            static fn(Directory $merged, $file) => $merged->add($file),
+        );
     }
 
     /**
@@ -126,6 +150,13 @@ private function apply(Adapter $adapter): Attempt
         return $this
             ->mutations
             ->sink(SideEffect::identity)
-            ->attempt(static fn($_, $mutate) => $mutate($adapter));
+            ->attempt(static fn($_, $mutation) => $adapter->add($mutation));
+    }
+
+    private function reset(): void
+    {
+        $this->notCommitted = Adapter::inMemory();
+        $this->mutations = $this->mutations->clear();
+        $this->removals = $this->removals->clear();
     }
 }