Merge pull request #1 from grixu/dev/3.0

Dev/3.0

Author: grixu

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to `api-client` will be documented in this file
 
+## 3.0.0 - 2021-02-12
+
+- Huge rebuild package both in concept and code layer.
+- Uses PHP8, dropped PHP 7.4 compatibility.
+- More concentrated on delivery flexible package that could be use directly in apps rather than in other packages
+- Made interfaces & classes for configuration, authorization, data fetching, containing & parsing to final classes delivered by user
+- Prepared classes for config, url creating & fetching data from JSON API
+
 ## 2.0.1 - 2021-01-20
 
 - Updated to be compatible with PHP8

README.md

@@ -1,6 +1,6 @@
 # API Client
 
-Simple API Client with OAuth2 Auth handler. 
+Simple API Client with OAuth2 Auth handler.
 
 ## Installation
 
@@ -10,39 +10,79 @@ You can install the package via composer:
 composer require grixu/api-client
 ```
 
-## Usage
+## Usage for JSON API
+
+### Create configuration object
+
+```php
+use Grixu\ApiClient\Config\JsonApiConfig;
+use Grixu\ApiClient\Data\PaginatedData;
+use Grixu\ApiClient\Data\StraightKeyParser;
+
+$config =  new JsonApiConfig(
+            baseUrl: 'http://rywal.com.pl',
+            responseDataClass: PaginatedData::class,
+            responseParserClass: StraightKeyParser::class,
+            authType: 'oAuth2',  // or you can use enum: AuthType::OAUTH2()
+            authUrl: 'http://rywal.com.pl',
+            authData: ['key', 'secret'],
+            paginationParam: 'page',
+            filters: ['list', 'of', 'param', 'names', 'that', 'could', 'be', 'used', 'as', 'filters'],
+            includes: ['same', 'but', 'for', 'includes'],
+            sorts: ['same', 'this', 'time', 'for', 'sort', 'options']
+        );
+```
+
+If you have various values of filter names, or extensive API to handle - consider creating Factory which will be
+handling creating `JsonApiConfig`. Or keep them in separate config file.
+
+### Create fetcher
+
+```php
+use Grixu\ApiClient\JsonApiFetcher;
+
+$fetcher = new JsonApiFetcher($config, '/api/path');
+```
 
+Here, you can adjust your query using `UrlCompose` by adding filters, sorts, includes:
 
-Then you can just simply call:
+```php
+// in every example you could pass multiple values
+$fetcher->compose()->addFilter('filter_name', 'filter_value_1');
+$fetcher->compose()->addInclude('include', 'include_relationship_1', 'include_relationship_2');
+$fetcher->compose()->addSort('sort', 'sort_field');
 
-``` php
-use Grixu\ApiClient\ApiClient;
+//also you could set page in pagination
+$fetcher->compose()->setPage('page', 2);
+// or simply move to next page by hand
+$fetcher->composer->nextPage();
+```
 
-$client = ApiClient::make(
-    'base Url',
-    'oAuth Url',
-    'client ID',
-    'client Key',
-    'cache key',
-);
+#### Fetch Data
 
-$response = $client->call('url path like /products');
+```php
+$fetcher->fetch();
+$parsedCollection = $parser->parse(DtoClass::class);
 ```
 
-### Configuration
+`$parsedCollection` is `\Illuminate\Support\Collection` filled with DTOs you
+
+## Configuration
+
 You can adjust global configuration of APIClient in your `.env` file:
+
 ```dotenv
 API_ERROR_LOGGING=true
 API_ERROR_LOG_CHANNEL="api-client"
 ```
 
-### Testing
+## Testing
 
 ``` bash
 composer test
 ```
 
-### Changelog
+## Changelog
 
 Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.
 

composer.json

@@ -16,13 +16,16 @@
         }
     ],
     "require": {
-        "php": "^7.4|^8.0",
+        "php": "^8.0",
         "ext-json": "*",
         "guzzlehttp/guzzle": "^7.2",
+        "guzzlehttp/psr7": "^1.7",
         "illuminate/http": "^8.0",
-        "illuminate/support": "^8.0"
+        "illuminate/support": "^8.0",
+        "spatie/laravel-enum": "^2.2"
     },
     "require-dev": {
+        "spatie/data-transfer-object": "^2.8",
         "orchestra/testbench": "^6.0",
         "phpunit/phpunit": "^9.4"
     },

config/config.php

@@ -1,9 +1,10 @@
 <?php
 
-/*
- * You can place your custom package configuration in here.
- */
 return [
+    'auth_types' => [
+        \Grixu\ApiClient\Enums\AuthType::OAUTH2()->value => \Grixu\ApiClient\Auth\OAuthToken::class
+    ],
+
     'logging' => env('API_ERROR_LOGGING', false),
     'log_channel' => env('API_ERROR_LOG_CHANNEL', 'api-client'),
 ];

src/AbstractApiFetcher.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Grixu\ApiClient;
+
+use Closure;
+use Grixu\ApiClient\Contracts\ApiFetcher;
+use Grixu\ApiClient\Contracts\Config;
+use Grixu\ApiClient\Contracts\TokenAuth;
+use Illuminate\Support\Collection;
+
+abstract class AbstractApiFetcher implements ApiFetcher
+{
+    protected ?TokenAuth $token;
+
+    protected Collection $dataCollection;
+
+    public function __construct(
+        private Config $config,
+        private string $path
+    ) {
+        $tokenClassName = config('api-client.auth_types')[$config->getAuthType()->value];
+        $this->token = new $tokenClassName($config);
+
+        $this->dataCollection = collect();
+    }
+
+    protected function callClosure(?Closure $closure)
+    {
+        if ($closure) {
+            $closure->call($this);
+        }
+    }
+
+    public function getDataCollection(): Collection
+    {
+        return $this->dataCollection;
+    }
+
+    public function parse(string $dtoClass)
+    {
+        $parserClassName = $this->config->getResponseParserClass();
+        $parser = new $parserClassName($dtoClass);
+
+        $flattenData = $this->dataCollection->flatten(1);
+        return $parser->parse($flattenData);
+    }
+}

src/ApiClient.php

@@ -17,12 +17,6 @@ public function boot()
 
     public function register()
     {
-        // Automatically apply the package configuration
         $this->mergeConfigFrom(__DIR__.'/../config/config.php', 'api-client');
-
-        // Register the main class to use with the facade
-        $this->app->bind('api-client', function () {
-            return new ApiClient;
-        });
     }
 }

src/ApiClientFacade.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Grixu\ApiClient\Auth;
+
+class AuthData
+{
+    public function __construct(protected string $key, protected string $secret)
+    {}
+
+    public function getKey(): string
+    {
+        return $this->key;
+    }
+
+    public function getSecret(): string
+    {
+        return $this->secret;
+    }
+}

src/ApiClientServiceProvider.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Grixu\ApiClient\Auth;
+
+use Grixu\ApiClient\Contracts\Config;
+use Grixu\ApiClient\Contracts\TokenAuth;
+use Grixu\ApiClient\Enums\AuthType;
+use Grixu\ApiClient\Exceptions\InvalidAuthTypeException;
+use Grixu\ApiClient\Exceptions\TokenIssueException;
+use Illuminate\Http\Client\Response;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+
+class OAuthToken implements TokenAuth
+{
+    private Config $config;
+    private ?string $token;
+    private string $cacheName;
+
+    public function __construct(Config $config)
+    {
+        $this->config = $config;
+        $this->validateAuthType();
+        $this->generateCacheName();
+    }
+
+    protected function validateAuthType()
+    {
+        if ($this->config->getAuthType() != AuthType::OAUTH2()) {
+            throw new InvalidAuthTypeException();
+        }
+    }
+
+    private function generateCacheName(): void
+    {
+        $this->cacheName = md5($this->config->getAuthUrl() . $this->config->getAuthType()->value);
+    }
+
+    public function getToken(): string
+    {
+        if (empty($this->token)) {
+            $this->authorize();
+        }
+
+        return $this->token;
+    }
+
+    public function authorize(): void
+    {
+        try {
+            $this->getTokenFromCache();
+        } catch (\Exception) {
+            $this->getTokenFromAuthServer();
+        }
+    }
+
+    private function getTokenFromCache(): void
+    {
+        $this->token = Cache::get($this->cacheName);
+
+        if (empty($this->token)) {
+            throw new \Exception('Empty cache');
+        }
+    }
+
+    private function getTokenFromAuthServer(): void
+    {
+        $tokenResponse = $this->makeAuthRequest();
+        $this->validateAuthResponse($tokenResponse);
+
+        $this->token = $tokenResponse->json('access_token');
+        Cache::put($this->cacheName, $this->token);
+    }
+
+    private function makeAuthRequest(): Response
+    {
+        return Http::withHeaders(
+            [
+                'Accept' => 'application/json'
+            ]
+        )
+            ->post(
+                $this->config->getAuthUrl(),
+                [
+                    'grant_type' => 'client_credentials',
+                    'client_id' => $this->config->getAuthData()->getKey(),
+                    'client_secret' => $this->config->getAuthData()->getSecret(),
+                    'scope' => '*',
+                ]
+            );
+    }
+
+    private function validateAuthResponse(Response $authResponse): void
+    {
+        if (!$authResponse->successful()) {
+            throw new TokenIssueException($authResponse->body());
+        }
+    }
+
+    public function reset(): void
+    {
+        Cache::forget($this->cacheName);
+        $this->getTokenFromAuthServer();
+    }
+}