Laravel Türkiye Discord Kanalı Forumda kod paylaşılırken dikkat edilmesi gerekenler!Birlikte proje geliştirmek ister misiniz?

Design Pattern Önerisi

myusuf

Bir proje için öneri arıyorum.
Proje: 2 ayrı provider'dan gelecek to-do iş bilgilerini çekerek...

Ekstra olarak şöyle de bi açıklama var: Burada iş listesini veren servisler Design Pattern ile geliştirilmeli ki daha sonra 3. bir iş listesi veren API'nin eklenmesi gerekirse bu sadece API tanıtımı ile yapılabilsin.

Ben de kurgu olarak şunu kurdum: Her provider için yeni bir class oluşturup ProviderInterface implement edeceğim. Daha sonra config/providers.php dosyası oluşturup providerları içine yazıp komut dosyasında foreach ile hepsini döneceğim.

Bu mantık doğru mu? Daha fazla nasıl geliştirilebilir? Yorumlarınız bekliyorum.

Provider 1

[
    {
        "id": 1,
        "value": 3,
        "estimated_duration": 4
    },
    {
        "id": 2,
        "value": 6,
        "estimated_duration": 12
    },
    {
        "id": 3,
        "value": 5,
        "estimated_duration": 9
    }

Provider 2

[
    {
        "id": 1,
        "zorluk": 3,
        "sure": 5
    },
    {
        "id": 2,
        "zorluk": 2,
        "sure": 3
    },
    {
        "id": 3,
        "zorluk": 1,
        "sure": 2
    },

ProviderInterface:

interface ProviderInterface
{
    public function __construct(TaskRepository $taskRepository);
    public function fetch(): array;
    public function save(array $task): void;
}

ProviderOneService:

class ProviderOneService implements ProviderInterface
{
    const KEY = 'provider_one';
    const URL = 'URL';

    public function __construct(private TaskRepository $taskRepository) {}

    public function fetch(): array
    {
        $isSuccess = false;
        $body = null;

        try {
            $body = Http::get(self::URL)->throw()->json();
            $isSuccess = true;
        } catch (RequestException $e) {
            $body = 'Server connection failed: ' . $e->getMessage();
        } catch (Exception $e) {
            $body = 'An unexpected error occurred: ' . $e->getMessage();
        }

        return [
            'success' => $isSuccess,
            'body' => $body
        ];
    }

    public function save(array $task): void
    {
        $this->taskRepository->save(self::KEY, $task['id'], $task['value'], $task['estimated_duration']);
    }
}

ProviderTwoService:

class ProviderTwoService implements ProviderInterface
{
    const KEY = 'provider_two';
    const URL = 'URL';

    public function __construct(private TaskRepository $taskRepository) {}

    public function fetch(): array
    {
        $isSuccess = false;
        $body = null;

        try {
            $body = Http::get(self::URL)->throw()->json();
            $isSuccess = true;
        } catch (RequestException $e) {
            $body = 'Server connection failed: ' . $e->getMessage();
        } catch (Exception $e) {
            $body = 'An unexpected error occurred: ' . $e->getMessage();
        }

        return [
            'success' => $isSuccess,
            'body' => $body
        ];
    }

    public function save(array $task): void
    {
        $this->taskRepository->save(self::KEY, $task['id'], $task['zorluk'], $task['sure']);
    }
}

config/providers.php

<?php

use App\Services\ProviderOneService;
use App\Services\ProviderTwoService;

return [
    ProviderOneService::class,
    ProviderTwoService::class,
    // Add new povider services here
];

Komut dosyası

public function handle()
    {
        $providers = config('providers');

        foreach ($providers as $provider) {
            try {
                $service = ProviderFactory::create($provider);
                $response = $service->fetch();

                if (!$response['success']) {
                    throw new Exception($response['body']);
                }

                foreach ($response['body'] as $task) {
                    $service->save($task);
                }
            } catch (Exception $e) {
                Log::channel('command')->error($e->getMessage());
            }
        }
    }

ProviderFactory:

public static function create(string $provider): ProviderInterface
    {
        $service = app($provider);
        
        if (!$service instanceof ProviderInterface) {
            throw new Exception(sprintf('Class %s does not implement ProviderInterface!', $provider));
        }

        return $service;
    }

mgsmus

myusuf Tasarım desenleri açısından kodunuzu yorumlarsak;

ProviderOneService ve ProviderTwoService dedikleriniz adapter.
Komut dosyasında yaptığınız işi yapan bir sınıfa daha ihtiyacınız var. Bu da bir manager olacak. Adapter içinde TaskRepository kullanmayacaksınız, onu manager içinde kullanacaksınız. Adapter'in görevi sadece veriyi çekmek olacak.
Adapter sınıflar aynı tip veriyi vermek zorunda olduklarından dolayı fetch yöntemleri array içinde bir Data Transfer Object verirse daha iyi olur.
ProviderFactory kısmı için her bir sınıfa alias verip match ile sınıfı bulmak daha mantıklı olur.

Bu durumda, şöyle bir şeyler düşünebiliriz:

interface ProviderAdapter
{
    /**
     * @return ProviderResult[]
     */
    public function fetch(): array;
}

readonly class ProviderResult implements Arrayable
{
    public function __construct(
        public string $provider,
        public int $id,
        public int $value,
        public int $duration
    )
    {}

    public function toArray(): array
    {
        return [
            'provider' => $this->provider,
            'id' => $this->id,
            'value' => $this->value,
            'duration' => $this->duration,
        ];
    }
}

class ProviderOne implements ProviderAdapter
{
    public const NAME = 'provider_one';

    public function __construct(
        public array $options = []
    )
    {}

    public function fetch(): array
    {
        $response = Http::get('https://...')
            ->throw()
            ->json();

        $data = [];

        foreach ($response as $item) {
            $data[] = new ProviderResult(
                $item['id'],
                $item['value'],
                $item['estimated_duration'],
            );
        }

        return $data;
    }
}

class ProviderTwo implements ProviderAdapter
{
    public const NAME = 'provider_two';

    public function __construct(
        public array $options = []
    )
    {}
    
    public function fetch(): array
    {
        $response = Http::get('https://...')
            ->throw()
            ->json();

        $data = [];

        foreach ($response as $item) {
            $data[] = new ProviderResult(
                $item['id'],
                $item['zorluk'],
                $item['sure'],
            );
        }

        return $data;
    }
}

class ProviderFactory
{
    public static function create(string $provider, array $options = []): ProviderAdapter
    {
        return match ($provider) {
            ProviderOne::NAME => new ProviderOne($options),
            ProviderTwo::NAME => new ProviderTwo($options),
            default: throw new Exception(sprintf('Invalid provider %s', $provider))
        };
    }
}

class ProviderManager
{
    public array $providers = [
        ProviderOne::NAME,
        ProviderTwo::NAME,
    ];

    public function __construct(
        public TaskRepository $taskRepository,
    ){}

    public function handle(): void
    {
        $data = [];

        foreach ($this->providers as $name) {
            $data[] = ProviderFactory::create($name)
                ->fetch();
        }

        $data = array_merge(...$data);

        foreach ($data as $result) {
            $this->taskRepository
                ->save(
                    $result->provider,
                    $result->id,
                    $result->value,
                    $result->duration,
                );
        }
    }
}

Artık komut içinde ya da herhangi bir yerde kullanabilirsiniz:

public function handle(ProviderManager $providerManager)
{
    $providerManager->handle();

    //...
}