Allow to use AtomicServiceInterface in a broad sense.

Author: rez1dent3

src/Internal/Service/LockService.php

@@ -12,6 +12,11 @@
 
 final class LockService implements LockServiceInterface
 {
+    /**
+     * @var array<string, bool>
+     */
+    private array $lockedKeys = [];
+
     private CacheRepository $cache;
 
     private int $seconds;
@@ -27,10 +32,20 @@ public function __construct(CacheFactory $cacheFactory)
      */
     public function block(string $key, callable $callback): mixed
     {
-        return $this->getLockProvider()
-            ->lock($key)
-            ->block($this->seconds, $callback)
-        ;
+        if (array_key_exists($key, $this->lockedKeys)) {
+            return $callback();
+        }
+
+        $this->lockedKeys[$key] = true;
+
+        try {
+            return $this->getLockProvider()
+                ->lock($key)
+                ->block($this->seconds, $callback)
+            ;
+        } finally {
+            unset($this->lockedKeys[$key]);
+        }
     }
 
     /**

src/Services/AssistantServiceInterface.php

@@ -12,20 +12,26 @@
 interface AssistantServiceInterface
 {
     /**
+     * Helps to quickly extract the uuid from an object.
+     *
      * @param non-empty-array<array-key, TransactionDtoInterface|TransferDtoInterface> $objects
      *
      * @return non-empty-array<array-key, string>
      */
     public function getUuids(array $objects): array;
 
     /**
+     * Helps to quickly calculate the amount.
+     *
      * @param non-empty-array<TransactionDtoInterface> $transactions
      *
      * @return array<int, string>
      */
     public function getSums(array $transactions): array;
 
     /**
+     * Helps to get cart meta data for a product.
+     *
      * @return array<mixed>|null
      */
     public function getMeta(BasketDtoInterface $basketDto, ProductInterface $product): ?array;

src/Services/AtmServiceInterface.php

@@ -12,13 +12,17 @@
 interface AtmServiceInterface
 {
     /**
+     * Helps to get to create a bunch of transaction objects.
+     *
      * @param non-empty-array<array-key, TransactionDtoInterface> $objects
      *
      * @return non-empty-array<string, Transaction>
      */
     public function makeTransactions(array $objects): array;
 
     /**
+     * Helps to get to create a bunch of transfer objects.
+     *
      * @param non-empty-array<array-key, TransferDtoInterface> $objects
      *
      * @return non-empty-array<string, Transfer>

src/Services/AtomicService.php

@@ -26,6 +26,24 @@ public function __construct(
     ) {
     }
 
+    /**
+     * @param non-empty-array<Wallet> $objects
+     *
+     * @throws LockProviderNotFoundException
+     * @throws RecordsNotFoundException
+     * @throws TransactionFailedException
+     * @throws ExceptionInterface
+     */
+    public function blocks(array $objects, callable $callback): mixed
+    {
+        $callable = fn () => $this->databaseService->transaction($callback);
+        foreach ($objects as $object) {
+            $callable = fn () => $this->lockService->block($this->key($object), $callable);
+        }
+
+        return $callable();
+    }
+
     /**
      * @throws LockProviderNotFoundException
      * @throws RecordsNotFoundException
@@ -34,10 +52,7 @@ public function __construct(
      */
     public function block(Wallet $object, callable $callback): mixed
     {
-        return $this->lockService->block(
-            $this->key($object),
-            fn () => $this->databaseService->transaction($callback)
-        );
+        return $this->blocks([$object], $callback);
     }
 
     private function key(Wallet $object): string

src/Services/AtomicServiceInterface.php

@@ -13,6 +13,8 @@
 interface AtomicServiceInterface
 {
     /**
+     * The method atomically locks the transaction for other concurrent requests.
+     *
      * @template T
      * @param callable(): T $callback
      * @return T
@@ -23,4 +25,20 @@ interface AtomicServiceInterface
      * @throws ExceptionInterface
      */
     public function block(Wallet $object, callable $callback): mixed;
+
+    /**
+     * Use when you need to atomically change a lot of wallets and atomic in its pure form is not suitable. Use with
+     * caution, generates N requests to the lock service.
+     *
+     * @template T
+     * @param non-empty-array<Wallet> $objects
+     * @param callable(): T $callback
+     * @return T
+     *
+     * @throws LockProviderNotFoundException
+     * @throws RecordsNotFoundException
+     * @throws TransactionFailedException
+     * @throws ExceptionInterface
+     */
+    public function blocks(array $objects, callable $callback): mixed;
 }

src/Services/BasketServiceInterface.php

@@ -8,5 +8,8 @@
 
 interface BasketServiceInterface
 {
+    /**
+     * A quick way to check stock. Able to check in batches, necessary for quick payments.
+     */
     public function availability(AvailabilityDtoInterface $availabilityDto): bool;
 }

src/Services/EagerLoaderServiceInterface.php

@@ -6,6 +6,9 @@
 
 use Bavix\Wallet\Internal\Dto\BasketDtoInterface;
 
+/**
+ * Ad hoc solution... Needed for internal purposes only. Helps to optimize greedy queries inside laravel.
+ */
 interface EagerLoaderServiceInterface
 {
     public function loadWalletsByBasket(BasketDtoInterface $basketDto): void;

src/Services/ExchangeServiceInterface.php

@@ -4,7 +4,13 @@
 
 namespace Bavix\Wallet\Services;
 
+/**
+ * Currency exchange contract between wallets.
+ */
 interface ExchangeServiceInterface
 {
+    /**
+     * Currency conversion method.
+     */
     public function convertTo(string $fromCurrency, string $toCurrency, float|int|string $amount): string;
 }

tests/Units/Service/AtomicServiceTest.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Bavix\Wallet\Test\Units\Service;
+
+use Bavix\Wallet\Services\AtomicServiceInterface;
+use Bavix\Wallet\Test\Infra\Factories\BuyerFactory;
+use Bavix\Wallet\Test\Infra\Models\Buyer;
+use Bavix\Wallet\Test\Infra\TestCase;
+
+/**
+ * @internal
+ */
+final class AtomicServiceTest extends TestCase
+{
+    public function testBlock(): void
+    {
+        $atomic = app(AtomicServiceInterface::class);
+
+        /** @var Buyer $user1 */
+        /** @var Buyer $user2 */
+        [$user1, $user2] = BuyerFactory::times(2)->create();
+
+        $user1->deposit(1000);
+
+        $atomic->blocks(
+            [$user1->wallet, $user2->wallet],
+            fn () => collect([
+                fn () => $user1->transfer($user2, 500),
+                fn () => $user1->transfer($user2, 500),
+                fn () => $user2->transfer($user1, 500),
+            ])
+                ->map(fn ($fx) => $fx()),
+        );
+
+        self::assertSame(1, $user2->transfers()->count());
+        self::assertSame(2, $user1->transfers()->count());
+        self::assertSame(3, $user2->transactions()->count());
+        self::assertSame(4, $user1->transactions()->count());
+
+        self::assertSame(500, $user1->balanceInt);
+        self::assertSame(500, $user2->balanceInt);
+    }
+}

tests/Units/Service/LockServiceTest.php

@@ -15,8 +15,40 @@ final class LockServiceTest extends TestCase
     public function testBlock(): void
     {
         $lock = app(LockServiceInterface::class);
-        $lock->block('hello', static fn () => 'hello world');
-        $lock->block('hello', static fn () => 'hello world');
+
+        $message = $lock->block(__METHOD__, static fn () => 'hello world');
+        self::assertSame('hello world', $message);
+
+        $message = $lock->block(__METHOD__, static fn () => 'hello world');
+        self::assertSame('hello world', $message);
+
+        self::assertTrue(true);
+    }
+
+    public function testLockFailed(): void
+    {
+        $lock = app(LockServiceInterface::class);
+
+        try {
+            $lock->block(__METHOD__, static fn () => throw new \Exception('hello world'));
+        } catch (\Throwable $throwable) {
+            self::assertSame('hello world', $throwable->getMessage());
+        }
+
+        $message = $lock->block(__METHOD__, static fn () => 'hello world');
+        self::assertSame('hello world', $message);
+        self::assertTrue(true);
+    }
+
+    public function testLockDeep(): void
+    {
+        $lock = app(LockServiceInterface::class);
+        $message = $lock->block(
+            __METHOD__,
+            static fn () => $lock->block(__METHOD__, static fn () => 'hello world'),
+        );
+
+        self::assertSame('hello world', $message);
         self::assertTrue(true);
     }
 }